// $ANTLR 3.3 Nov 30, 2010 12:45:30 C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g 2011-06-26 23:15:57
 package AntlrParser; 

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import Expressions.*;


import org.antlr.runtime.tree.*;

public class HbaseSQLParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "Eq", "Neq1", "Neq2", "Le1", "Le2", "Lt", "Ge1", "Ge2", "Gt", "DIV", "PLUS", "MINUS", "MUL", "MOD", "BITAND", "BITNOT", "BITOR", "BITXOR", "LPAREN", "RPAREN", "COLON", "COMMA", "SEMI", "DOT", "ALL", "AND", "AS", "ASC", "BETWEEN", "BY", "CASE", "CROSS", "DELETE", "DESC", "DISTINCT", "ELSE", "END", "EXISTS", "FOR", "FROM", "GROUP", "HAVING", "IN", "INNER", "INSERT", "INTO", "IS", "JOIN", "LEFT", "LIKE", "NOT", "NULL", "ON", "OR", "ORDER", "OUTER", "RIGHT", "SELECT", "SET", "THEN", "UNION", "UPDATE", "VALUES", "WHEN", "WHERE", "TRUNCATE", "SUM", "AVG", "MAX", "MIN", "COUNT", "LEN", "CHAR", "NCHAR", "VARCHAR", "NVARCHAR", "TEXT", "NTEXT", "DATETIME", "INT", "DECIMAL", "BINARY", "CREATE", "TABLE", "DROP", "QuotedIdentifier", "NonQuotedIdentifier", "Integer", "StringLiteral", "Real", "UserVariable", "Whitespace", "SingleLineComment", "MultiLineComment", "DigitChar", "NonQuotedIdentifier_0", "LetterChar", "TextNode", "SelectClause", "UnionStmt", "SelectStmt", "WhereClause", "GroupByClause", "OrderByClause", "OrderByItem", "UpdateClause", "UpdateStmt", "DeleteClause", "DeleteStmt", "InsertClause", "InsertStmt", "Alias", "Table", "JoinedTable", "Column", "Predicate", "Predicate_Is", "DataType", "Group", "UserFunction"
    };
    public static final int EOF=-1;
    public static final int Eq=4;
    public static final int Neq1=5;
    public static final int Neq2=6;
    public static final int Le1=7;
    public static final int Le2=8;
    public static final int Lt=9;
    public static final int Ge1=10;
    public static final int Ge2=11;
    public static final int Gt=12;
    public static final int DIV=13;
    public static final int PLUS=14;
    public static final int MINUS=15;
    public static final int MUL=16;
    public static final int MOD=17;
    public static final int BITAND=18;
    public static final int BITNOT=19;
    public static final int BITOR=20;
    public static final int BITXOR=21;
    public static final int LPAREN=22;
    public static final int RPAREN=23;
    public static final int COLON=24;
    public static final int COMMA=25;
    public static final int SEMI=26;
    public static final int DOT=27;
    public static final int ALL=28;
    public static final int AND=29;
    public static final int AS=30;
    public static final int ASC=31;
    public static final int BETWEEN=32;
    public static final int BY=33;
    public static final int CASE=34;
    public static final int CROSS=35;
    public static final int DELETE=36;
    public static final int DESC=37;
    public static final int DISTINCT=38;
    public static final int ELSE=39;
    public static final int END=40;
    public static final int EXISTS=41;
    public static final int FOR=42;
    public static final int FROM=43;
    public static final int GROUP=44;
    public static final int HAVING=45;
    public static final int IN=46;
    public static final int INNER=47;
    public static final int INSERT=48;
    public static final int INTO=49;
    public static final int IS=50;
    public static final int JOIN=51;
    public static final int LEFT=52;
    public static final int LIKE=53;
    public static final int NOT=54;
    public static final int NULL=55;
    public static final int ON=56;
    public static final int OR=57;
    public static final int ORDER=58;
    public static final int OUTER=59;
    public static final int RIGHT=60;
    public static final int SELECT=61;
    public static final int SET=62;
    public static final int THEN=63;
    public static final int UNION=64;
    public static final int UPDATE=65;
    public static final int VALUES=66;
    public static final int WHEN=67;
    public static final int WHERE=68;
    public static final int TRUNCATE=69;
    public static final int SUM=70;
    public static final int AVG=71;
    public static final int MAX=72;
    public static final int MIN=73;
    public static final int COUNT=74;
    public static final int LEN=75;
    public static final int CHAR=76;
    public static final int NCHAR=77;
    public static final int VARCHAR=78;
    public static final int NVARCHAR=79;
    public static final int TEXT=80;
    public static final int NTEXT=81;
    public static final int DATETIME=82;
    public static final int INT=83;
    public static final int DECIMAL=84;
    public static final int BINARY=85;
    public static final int CREATE=86;
    public static final int TABLE=87;
    public static final int DROP=88;
    public static final int QuotedIdentifier=89;
    public static final int NonQuotedIdentifier=90;
    public static final int Integer=91;
    public static final int StringLiteral=92;
    public static final int Real=93;
    public static final int UserVariable=94;
    public static final int Whitespace=95;
    public static final int SingleLineComment=96;
    public static final int MultiLineComment=97;
    public static final int DigitChar=98;
    public static final int NonQuotedIdentifier_0=99;
    public static final int LetterChar=100;
    public static final int TextNode=101;
    public static final int SelectClause=102;
    public static final int UnionStmt=103;
    public static final int SelectStmt=104;
    public static final int WhereClause=105;
    public static final int GroupByClause=106;
    public static final int OrderByClause=107;
    public static final int OrderByItem=108;
    public static final int UpdateClause=109;
    public static final int UpdateStmt=110;
    public static final int DeleteClause=111;
    public static final int DeleteStmt=112;
    public static final int InsertClause=113;
    public static final int InsertStmt=114;
    public static final int Alias=115;
    public static final int Table=116;
    public static final int JoinedTable=117;
    public static final int Column=118;
    public static final int Predicate=119;
    public static final int Predicate_Is=120;
    public static final int DataType=121;
    public static final int Group=122;
    public static final int UserFunction=123;

    // delegates
    // delegators


        public HbaseSQLParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public HbaseSQLParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return HbaseSQLParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g"; }


    public static class start_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "start"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:116:1: start : statements ;
    public final HbaseSQLParser.start_return start() throws RecognitionException {
        HbaseSQLParser.start_return retval = new HbaseSQLParser.start_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.statements_return statements1 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:116:6: ( statements )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:116:8: statements
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_statements_in_start953);
            statements1=statements();

            state._fsp--;

            adaptor.addChild(root_0, statements1.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "start"

    public static class statements_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statements"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:1: statements : ( statement ( ( SEMI )? ) )* EOF ;
    public final HbaseSQLParser.statements_return statements() throws RecognitionException {
        HbaseSQLParser.statements_return retval = new HbaseSQLParser.statements_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token SEMI3=null;
        Token EOF4=null;
        HbaseSQLParser.statement_return statement2 = null;


        CommonTree SEMI3_tree=null;
        CommonTree EOF4_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:11: ( ( statement ( ( SEMI )? ) )* EOF )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:13: ( statement ( ( SEMI )? ) )* EOF
            {
            root_0 = (CommonTree)adaptor.nil();

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:13: ( statement ( ( SEMI )? ) )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==DELETE||LA2_0==INSERT||LA2_0==SELECT||LA2_0==UPDATE||LA2_0==TRUNCATE||LA2_0==CREATE||LA2_0==DROP) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:14: statement ( ( SEMI )? )
            	    {
            	    pushFollow(FOLLOW_statement_in_statements962);
            	    statement2=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, statement2.getTree());
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:24: ( ( SEMI )? )
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:25: ( SEMI )?
            	    {
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:25: ( SEMI )?
            	    int alt1=2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0==SEMI) ) {
            	        alt1=1;
            	    }
            	    switch (alt1) {
            	        case 1 :
            	            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:117:25: SEMI
            	            {
            	            SEMI3=(Token)match(input,SEMI,FOLLOW_SEMI_in_statements965); 
            	            SEMI3_tree = (CommonTree)adaptor.create(SEMI3);
            	            adaptor.addChild(root_0, SEMI3_tree);


            	            }
            	            break;

            	    }


            	    }


            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);

            EOF4=(Token)match(input,EOF,FOLLOW_EOF_in_statements972); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "statements"

    public static class statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:119:1: statement : ( selectStatement | updateStatement | deleteStatement | insertStatement | createTableStatement | dropTableStatement );
    public final HbaseSQLParser.statement_return statement() throws RecognitionException {
        HbaseSQLParser.statement_return retval = new HbaseSQLParser.statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.selectStatement_return selectStatement5 = null;

        HbaseSQLParser.updateStatement_return updateStatement6 = null;

        HbaseSQLParser.deleteStatement_return deleteStatement7 = null;

        HbaseSQLParser.insertStatement_return insertStatement8 = null;

        HbaseSQLParser.createTableStatement_return createTableStatement9 = null;

        HbaseSQLParser.dropTableStatement_return dropTableStatement10 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:119:10: ( selectStatement | updateStatement | deleteStatement | insertStatement | createTableStatement | dropTableStatement )
            int alt3=6;
            switch ( input.LA(1) ) {
            case SELECT:
                {
                alt3=1;
                }
                break;
            case UPDATE:
                {
                alt3=2;
                }
                break;
            case DELETE:
            case TRUNCATE:
                {
                alt3=3;
                }
                break;
            case INSERT:
                {
                alt3=4;
                }
                break;
            case CREATE:
                {
                alt3=5;
                }
                break;
            case DROP:
                {
                alt3=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:122:2: selectStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_selectStatement_in_statement986);
                    selectStatement5=selectStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, selectStatement5.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:123:4: updateStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_updateStatement_in_statement991);
                    updateStatement6=updateStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, updateStatement6.getTree());

                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:124:4: deleteStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_deleteStatement_in_statement996);
                    deleteStatement7=deleteStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, deleteStatement7.getTree());

                    }
                    break;
                case 4 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:125:4: insertStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_insertStatement_in_statement1001);
                    insertStatement8=insertStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, insertStatement8.getTree());

                    }
                    break;
                case 5 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:126:4: createTableStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_createTableStatement_in_statement1006);
                    createTableStatement9=createTableStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, createTableStatement9.getTree());

                    }
                    break;
                case 6 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:127:4: dropTableStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_dropTableStatement_in_statement1011);
                    dropTableStatement10=dropTableStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, dropTableStatement10.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class createTableStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "createTableStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:130:1: createTableStatement : CREATE TABLE identifier columns ;
    public final HbaseSQLParser.createTableStatement_return createTableStatement() throws RecognitionException {
        HbaseSQLParser.createTableStatement_return retval = new HbaseSQLParser.createTableStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token CREATE11=null;
        Token TABLE12=null;
        HbaseSQLParser.identifier_return identifier13 = null;

        HbaseSQLParser.columns_return columns14 = null;


        CommonTree CREATE11_tree=null;
        CommonTree TABLE12_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:131:2: ( CREATE TABLE identifier columns )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:131:4: CREATE TABLE identifier columns
            {
            root_0 = (CommonTree)adaptor.nil();

            CREATE11=(Token)match(input,CREATE,FOLLOW_CREATE_in_createTableStatement1022); 
            CREATE11_tree = (CommonTree)adaptor.create(CREATE11);
            adaptor.addChild(root_0, CREATE11_tree);

            TABLE12=(Token)match(input,TABLE,FOLLOW_TABLE_in_createTableStatement1024); 
            TABLE12_tree = (CommonTree)adaptor.create(TABLE12);
            adaptor.addChild(root_0, TABLE12_tree);

            pushFollow(FOLLOW_identifier_in_createTableStatement1026);
            identifier13=identifier();

            state._fsp--;

            adaptor.addChild(root_0, identifier13.getTree());
            pushFollow(FOLLOW_columns_in_createTableStatement1028);
            columns14=columns();

            state._fsp--;

            adaptor.addChild(root_0, columns14.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "createTableStatement"

    public static class dropTableStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "dropTableStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:134:1: dropTableStatement : DROP TABLE identifier ;
    public final HbaseSQLParser.dropTableStatement_return dropTableStatement() throws RecognitionException {
        HbaseSQLParser.dropTableStatement_return retval = new HbaseSQLParser.dropTableStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token DROP15=null;
        Token TABLE16=null;
        HbaseSQLParser.identifier_return identifier17 = null;


        CommonTree DROP15_tree=null;
        CommonTree TABLE16_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:135:2: ( DROP TABLE identifier )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:135:4: DROP TABLE identifier
            {
            root_0 = (CommonTree)adaptor.nil();

            DROP15=(Token)match(input,DROP,FOLLOW_DROP_in_dropTableStatement1039); 
            DROP15_tree = (CommonTree)adaptor.create(DROP15);
            adaptor.addChild(root_0, DROP15_tree);

            TABLE16=(Token)match(input,TABLE,FOLLOW_TABLE_in_dropTableStatement1041); 
            TABLE16_tree = (CommonTree)adaptor.create(TABLE16);
            adaptor.addChild(root_0, TABLE16_tree);

            pushFollow(FOLLOW_identifier_in_dropTableStatement1043);
            identifier17=identifier();

            state._fsp--;

            adaptor.addChild(root_0, identifier17.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "dropTableStatement"

    public static class selectStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "selectStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:138:1: selectStatement : select_1 ( UNION ( ALL )? select_2 )* ( orderBy )? -> {isUnion}? ^( UnionStmt ^( SelectStmt select_1 ) ( ^( TextNode UNION ( ALL )? ) ^( SelectStmt select_2 ) )+ ( orderBy )? ) -> {!isUnion}? ^( SelectStmt select_1 ( orderBy )? ) ->;
    public final HbaseSQLParser.selectStatement_return selectStatement() throws RecognitionException {
        HbaseSQLParser.selectStatement_return retval = new HbaseSQLParser.selectStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token UNION19=null;
        Token ALL20=null;
        HbaseSQLParser.select_1_return select_118 = null;

        HbaseSQLParser.select_2_return select_221 = null;

        HbaseSQLParser.orderBy_return orderBy22 = null;


        CommonTree UNION19_tree=null;
        CommonTree ALL20_tree=null;
        RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
        RewriteRuleTokenStream stream_ALL=new RewriteRuleTokenStream(adaptor,"token ALL");
        RewriteRuleSubtreeStream stream_select_1=new RewriteRuleSubtreeStream(adaptor,"rule select_1");
        RewriteRuleSubtreeStream stream_select_2=new RewriteRuleSubtreeStream(adaptor,"rule select_2");
        RewriteRuleSubtreeStream stream_orderBy=new RewriteRuleSubtreeStream(adaptor,"rule orderBy");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:2: ( select_1 ( UNION ( ALL )? select_2 )* ( orderBy )? -> {isUnion}? ^( UnionStmt ^( SelectStmt select_1 ) ( ^( TextNode UNION ( ALL )? ) ^( SelectStmt select_2 ) )+ ( orderBy )? ) -> {!isUnion}? ^( SelectStmt select_1 ( orderBy )? ) ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:4: select_1 ( UNION ( ALL )? select_2 )* ( orderBy )?
            {
            boolean isUnion=false;
            pushFollow(FOLLOW_select_1_in_selectStatement1057);
            select_118=select_1();

            state._fsp--;

            stream_select_1.add(select_118.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:38: ( UNION ( ALL )? select_2 )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==UNION) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:39: UNION ( ALL )? select_2
            	    {
            	    UNION19=(Token)match(input,UNION,FOLLOW_UNION_in_selectStatement1060);  
            	    stream_UNION.add(UNION19);

            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:45: ( ALL )?
            	    int alt4=2;
            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0==ALL) ) {
            	        alt4=1;
            	    }
            	    switch (alt4) {
            	        case 1 :
            	            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:45: ALL
            	            {
            	            ALL20=(Token)match(input,ALL,FOLLOW_ALL_in_selectStatement1062);  
            	            stream_ALL.add(ALL20);


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_select_2_in_selectStatement1065);
            	    select_221=select_2();

            	    state._fsp--;

            	    stream_select_2.add(select_221.getTree());
            	    isUnion=true;

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:77: ( orderBy )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==ORDER) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:139:77: orderBy
                    {
                    pushFollow(FOLLOW_orderBy_in_selectStatement1071);
                    orderBy22=orderBy();

                    state._fsp--;

                    stream_orderBy.add(orderBy22.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: orderBy, select_1, ALL, select_1, orderBy, select_2, UNION
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 140:4: -> {isUnion}? ^( UnionStmt ^( SelectStmt select_1 ) ( ^( TextNode UNION ( ALL )? ) ^( SelectStmt select_2 ) )+ ( orderBy )? )
            if (isUnion) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:17: ^( UnionStmt ^( SelectStmt select_1 ) ( ^( TextNode UNION ( ALL )? ) ^( SelectStmt select_2 ) )+ ( orderBy )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UnionStmt, "UnionStmt"), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:29: ^( SelectStmt select_1 )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SelectStmt, "SelectStmt"), root_2);

                adaptor.addChild(root_2, stream_select_1.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                if ( !(stream_select_2.hasNext()||stream_UNION.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_select_2.hasNext()||stream_UNION.hasNext() ) {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:53: ^( TextNode UNION ( ALL )? )
                    {
                    CommonTree root_2 = (CommonTree)adaptor.nil();
                    root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                    adaptor.addChild(root_2, stream_UNION.nextNode());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:70: ( ALL )?
                    if ( stream_ALL.hasNext() ) {
                        adaptor.addChild(root_2, stream_ALL.nextNode());

                    }
                    stream_ALL.reset();

                    adaptor.addChild(root_1, root_2);
                    }
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:76: ^( SelectStmt select_2 )
                    {
                    CommonTree root_2 = (CommonTree)adaptor.nil();
                    root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SelectStmt, "SelectStmt"), root_2);

                    adaptor.addChild(root_2, stream_select_2.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_select_2.reset();
                stream_UNION.reset();
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:140:101: ( orderBy )?
                if ( stream_orderBy.hasNext() ) {
                    adaptor.addChild(root_1, stream_orderBy.nextTree());

                }
                stream_orderBy.reset();

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 141:4: -> {!isUnion}? ^( SelectStmt select_1 ( orderBy )? )
            if (!isUnion) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:141:18: ^( SelectStmt select_1 ( orderBy )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SelectStmt, "SelectStmt"), root_1);

                adaptor.addChild(root_1, stream_select_1.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:141:40: ( orderBy )?
                if ( stream_orderBy.hasNext() ) {
                    adaptor.addChild(root_1, stream_orderBy.nextTree());

                }
                stream_orderBy.reset();

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 142:4: ->
            {
                root_0 = null;
            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "selectStatement"

    public static class select_1_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "select_1"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:1: select_1 : select ( from )? ( where )? ( groupBy )? ;
    public final HbaseSQLParser.select_1_return select_1() throws RecognitionException {
        HbaseSQLParser.select_1_return retval = new HbaseSQLParser.select_1_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.select_return select23 = null;

        HbaseSQLParser.from_return from24 = null;

        HbaseSQLParser.where_return where25 = null;

        HbaseSQLParser.groupBy_return groupBy26 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:9: ( select ( from )? ( where )? ( groupBy )? )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:11: select ( from )? ( where )? ( groupBy )?
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_select_in_select_11138);
            select23=select();

            state._fsp--;

            adaptor.addChild(root_0, select23.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:18: ( from )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==FROM) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:18: from
                    {
                    pushFollow(FOLLOW_from_in_select_11140);
                    from24=from();

                    state._fsp--;

                    adaptor.addChild(root_0, from24.getTree());

                    }
                    break;

            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:24: ( where )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==WHERE) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:24: where
                    {
                    pushFollow(FOLLOW_where_in_select_11143);
                    where25=where();

                    state._fsp--;

                    adaptor.addChild(root_0, where25.getTree());

                    }
                    break;

            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:31: ( groupBy )?
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==GROUP) ) {
                alt9=1;
            }
            switch (alt9) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:145:31: groupBy
                    {
                    pushFollow(FOLLOW_groupBy_in_select_11146);
                    groupBy26=groupBy();

                    state._fsp--;

                    adaptor.addChild(root_0, groupBy26.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "select_1"

    public static class select_2_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "select_2"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:146:1: select_2 : select_1 ;
    public final HbaseSQLParser.select_2_return select_2() throws RecognitionException {
        HbaseSQLParser.select_2_return retval = new HbaseSQLParser.select_2_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.select_1_return select_127 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:146:9: ( select_1 )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:146:11: select_1
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_select_1_in_select_21153);
            select_127=select_1();

            state._fsp--;

            adaptor.addChild(root_0, select_127.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "select_2"

    public static class subQuery_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "subQuery"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:147:1: subQuery : LPAREN selectStatement RPAREN -> selectStatement ;
    public final HbaseSQLParser.subQuery_return subQuery() throws RecognitionException {
        HbaseSQLParser.subQuery_return retval = new HbaseSQLParser.subQuery_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LPAREN28=null;
        Token RPAREN30=null;
        HbaseSQLParser.selectStatement_return selectStatement29 = null;


        CommonTree LPAREN28_tree=null;
        CommonTree RPAREN30_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_selectStatement=new RewriteRuleSubtreeStream(adaptor,"rule selectStatement");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:147:9: ( LPAREN selectStatement RPAREN -> selectStatement )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:147:11: LPAREN selectStatement RPAREN
            {
            LPAREN28=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_subQuery1160);  
            stream_LPAREN.add(LPAREN28);

            pushFollow(FOLLOW_selectStatement_in_subQuery1162);
            selectStatement29=selectStatement();

            state._fsp--;

            stream_selectStatement.add(selectStatement29.getTree());
            RPAREN30=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_subQuery1164);  
            stream_RPAREN.add(RPAREN30);



            // AST REWRITE
            // elements: selectStatement
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 147:41: -> selectStatement
            {
                adaptor.addChild(root_0, stream_selectStatement.nextTree());

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "subQuery"

    public static class updateStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "updateStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:1: updateStatement : update ( from )? ( where )? ;
    public final HbaseSQLParser.updateStatement_return updateStatement() throws RecognitionException {
        HbaseSQLParser.updateStatement_return retval = new HbaseSQLParser.updateStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.update_return update31 = null;

        HbaseSQLParser.from_return from32 = null;

        HbaseSQLParser.where_return where33 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:16: ( update ( from )? ( where )? )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:18: update ( from )? ( where )?
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_update_in_updateStatement1175);
            update31=update();

            state._fsp--;

            adaptor.addChild(root_0, update31.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:25: ( from )?
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==FROM) ) {
                alt10=1;
            }
            switch (alt10) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:25: from
                    {
                    pushFollow(FOLLOW_from_in_updateStatement1177);
                    from32=from();

                    state._fsp--;

                    adaptor.addChild(root_0, from32.getTree());

                    }
                    break;

            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:31: ( where )?
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==WHERE) ) {
                alt11=1;
            }
            switch (alt11) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:148:31: where
                    {
                    pushFollow(FOLLOW_where_in_updateStatement1180);
                    where33=where();

                    state._fsp--;

                    adaptor.addChild(root_0, where33.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "updateStatement"

    public static class deleteStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "deleteStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:1: deleteStatement : ( delete ( where )? | truncate );
    public final HbaseSQLParser.deleteStatement_return deleteStatement() throws RecognitionException {
        HbaseSQLParser.deleteStatement_return retval = new HbaseSQLParser.deleteStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.delete_return delete34 = null;

        HbaseSQLParser.where_return where35 = null;

        HbaseSQLParser.truncate_return truncate36 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:16: ( delete ( where )? | truncate )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==DELETE) ) {
                alt13=1;
            }
            else if ( (LA13_0==TRUNCATE) ) {
                alt13=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:18: delete ( where )?
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_delete_in_deleteStatement1187);
                    delete34=delete();

                    state._fsp--;

                    adaptor.addChild(root_0, delete34.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:25: ( where )?
                    int alt12=2;
                    int LA12_0 = input.LA(1);

                    if ( (LA12_0==WHERE) ) {
                        alt12=1;
                    }
                    switch (alt12) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:25: where
                            {
                            pushFollow(FOLLOW_where_in_deleteStatement1189);
                            where35=where();

                            state._fsp--;

                            adaptor.addChild(root_0, where35.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:149:34: truncate
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_truncate_in_deleteStatement1194);
                    truncate36=truncate();

                    state._fsp--;

                    adaptor.addChild(root_0, truncate36.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "deleteStatement"

    public static class insertStatement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "insertStatement"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:1: insertStatement : insert ( values | selectStatement ) ;
    public final HbaseSQLParser.insertStatement_return insertStatement() throws RecognitionException {
        HbaseSQLParser.insertStatement_return retval = new HbaseSQLParser.insertStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.insert_return insert37 = null;

        HbaseSQLParser.values_return values38 = null;

        HbaseSQLParser.selectStatement_return selectStatement39 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:16: ( insert ( values | selectStatement ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:18: insert ( values | selectStatement )
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_insert_in_insertStatement1200);
            insert37=insert();

            state._fsp--;

            adaptor.addChild(root_0, insert37.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:25: ( values | selectStatement )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==VALUES) ) {
                alt14=1;
            }
            else if ( (LA14_0==SELECT) ) {
                alt14=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:26: values
                    {
                    pushFollow(FOLLOW_values_in_insertStatement1203);
                    values38=values();

                    state._fsp--;

                    adaptor.addChild(root_0, values38.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:150:35: selectStatement
                    {
                    pushFollow(FOLLOW_selectStatement_in_insertStatement1207);
                    selectStatement39=selectStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, selectStatement39.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "insertStatement"

    public static class select_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "select"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:153:1: select : SELECT ( DISTINCT )? columns -> ^( SelectClause SELECT ( DISTINCT )? columns ) ;
    public final HbaseSQLParser.select_return select() throws RecognitionException {
        HbaseSQLParser.select_return retval = new HbaseSQLParser.select_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token SELECT40=null;
        Token DISTINCT41=null;
        HbaseSQLParser.columns_return columns42 = null;


        CommonTree SELECT40_tree=null;
        CommonTree DISTINCT41_tree=null;
        RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
        RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
        RewriteRuleSubtreeStream stream_columns=new RewriteRuleSubtreeStream(adaptor,"rule columns");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:154:2: ( SELECT ( DISTINCT )? columns -> ^( SelectClause SELECT ( DISTINCT )? columns ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:154:4: SELECT ( DISTINCT )? columns
            {
            SELECT40=(Token)match(input,SELECT,FOLLOW_SELECT_in_select1220);  
            stream_SELECT.add(SELECT40);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:154:11: ( DISTINCT )?
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==DISTINCT) ) {
                alt15=1;
            }
            switch (alt15) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:154:11: DISTINCT
                    {
                    DISTINCT41=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_select1222);  
                    stream_DISTINCT.add(DISTINCT41);


                    }
                    break;

            }

            pushFollow(FOLLOW_columns_in_select1225);
            columns42=columns();

            state._fsp--;

            stream_columns.add(columns42.getTree());


            // AST REWRITE
            // elements: SELECT, columns, DISTINCT
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 155:2: -> ^( SelectClause SELECT ( DISTINCT )? columns )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:155:5: ^( SelectClause SELECT ( DISTINCT )? columns )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SelectClause, "SelectClause"), root_1);

                adaptor.addChild(root_1, stream_SELECT.nextNode());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:155:27: ( DISTINCT )?
                if ( stream_DISTINCT.hasNext() ) {
                    adaptor.addChild(root_1, stream_DISTINCT.nextNode());

                }
                stream_DISTINCT.reset();
                adaptor.addChild(root_1, stream_columns.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "select"

    public static class from_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "from"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:157:1: from : FROM tables ;
    public final HbaseSQLParser.from_return from() throws RecognitionException {
        HbaseSQLParser.from_return retval = new HbaseSQLParser.from_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token FROM43=null;
        HbaseSQLParser.tables_return tables44 = null;


        CommonTree FROM43_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:157:5: ( FROM tables )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:157:7: FROM tables
            {
            root_0 = (CommonTree)adaptor.nil();

            FROM43=(Token)match(input,FROM,FOLLOW_FROM_in_from1247); 
            FROM43_tree = (CommonTree)adaptor.create(FROM43);
            root_0 = (CommonTree)adaptor.becomeRoot(FROM43_tree, root_0);

            pushFollow(FOLLOW_tables_in_from1250);
            tables44=tables();

            state._fsp--;

            adaptor.addChild(root_0, tables44.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "from"

    public static class where_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "where"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:158:1: where : WHERE condition -> ^( WhereClause WHERE condition ) ;
    public final HbaseSQLParser.where_return where() throws RecognitionException {
        HbaseSQLParser.where_return retval = new HbaseSQLParser.where_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WHERE45=null;
        HbaseSQLParser.condition_return condition46 = null;


        CommonTree WHERE45_tree=null;
        RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
        RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:158:6: ( WHERE condition -> ^( WhereClause WHERE condition ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:158:8: WHERE condition
            {
            WHERE45=(Token)match(input,WHERE,FOLLOW_WHERE_in_where1257);  
            stream_WHERE.add(WHERE45);

            pushFollow(FOLLOW_condition_in_where1259);
            condition46=condition();

            state._fsp--;

            stream_condition.add(condition46.getTree());


            // AST REWRITE
            // elements: condition, WHERE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 158:24: -> ^( WhereClause WHERE condition )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:158:27: ^( WhereClause WHERE condition )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(WhereClause, "WhereClause"), root_1);

                adaptor.addChild(root_1, stream_WHERE.nextNode());
                adaptor.addChild(root_1, stream_condition.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "where"

    public static class orderBy_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "orderBy"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:160:1: orderBy : ORDER BY orderBy_1 ( COMMA orderBy_1 )* -> ^( OrderByClause ORDER BY ( orderBy_1 )+ ) ;
    public final HbaseSQLParser.orderBy_return orderBy() throws RecognitionException {
        HbaseSQLParser.orderBy_return retval = new HbaseSQLParser.orderBy_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token ORDER47=null;
        Token BY48=null;
        Token COMMA50=null;
        HbaseSQLParser.orderBy_1_return orderBy_149 = null;

        HbaseSQLParser.orderBy_1_return orderBy_151 = null;


        CommonTree ORDER47_tree=null;
        CommonTree BY48_tree=null;
        CommonTree COMMA50_tree=null;
        RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
        RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_orderBy_1=new RewriteRuleSubtreeStream(adaptor,"rule orderBy_1");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:161:2: ( ORDER BY orderBy_1 ( COMMA orderBy_1 )* -> ^( OrderByClause ORDER BY ( orderBy_1 )+ ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:161:4: ORDER BY orderBy_1 ( COMMA orderBy_1 )*
            {
            ORDER47=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderBy1279);  
            stream_ORDER.add(ORDER47);

            BY48=(Token)match(input,BY,FOLLOW_BY_in_orderBy1281);  
            stream_BY.add(BY48);

            pushFollow(FOLLOW_orderBy_1_in_orderBy1283);
            orderBy_149=orderBy_1();

            state._fsp--;

            stream_orderBy_1.add(orderBy_149.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:161:23: ( COMMA orderBy_1 )*
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0==COMMA) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:161:24: COMMA orderBy_1
            	    {
            	    COMMA50=(Token)match(input,COMMA,FOLLOW_COMMA_in_orderBy1286);  
            	    stream_COMMA.add(COMMA50);

            	    pushFollow(FOLLOW_orderBy_1_in_orderBy1288);
            	    orderBy_151=orderBy_1();

            	    state._fsp--;

            	    stream_orderBy_1.add(orderBy_151.getTree());

            	    }
            	    break;

            	default :
            	    break loop16;
                }
            } while (true);



            // AST REWRITE
            // elements: orderBy_1, ORDER, BY
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 162:2: -> ^( OrderByClause ORDER BY ( orderBy_1 )+ )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:162:5: ^( OrderByClause ORDER BY ( orderBy_1 )+ )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OrderByClause, "OrderByClause"), root_1);

                adaptor.addChild(root_1, stream_ORDER.nextNode());
                adaptor.addChild(root_1, stream_BY.nextNode());
                if ( !(stream_orderBy_1.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_orderBy_1.hasNext() ) {
                    adaptor.addChild(root_1, stream_orderBy_1.nextTree());

                }
                stream_orderBy_1.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "orderBy"

    public static class orderBy_1_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "orderBy_1"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:164:1: orderBy_1 : expressions ( ( ASC ) | ( DESC ) )? -> {orderMethod==0}? ^( OrderByItem expressions ) -> {orderMethod==1}? ^( OrderByItem expressions ASC ) -> {orderMethod==2}? ^( OrderByItem expressions DESC ) ->;
    public final HbaseSQLParser.orderBy_1_return orderBy_1() throws RecognitionException {
        HbaseSQLParser.orderBy_1_return retval = new HbaseSQLParser.orderBy_1_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token ASC53=null;
        Token DESC54=null;
        HbaseSQLParser.expressions_return expressions52 = null;


        CommonTree ASC53_tree=null;
        CommonTree DESC54_tree=null;
        RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
        RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:165:2: ( expressions ( ( ASC ) | ( DESC ) )? -> {orderMethod==0}? ^( OrderByItem expressions ) -> {orderMethod==1}? ^( OrderByItem expressions ASC ) -> {orderMethod==2}? ^( OrderByItem expressions DESC ) ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:165:4: expressions ( ( ASC ) | ( DESC ) )?
            {
            int orderMethod=0;
            pushFollow(FOLLOW_expressions_in_orderBy_11317);
            expressions52=expressions();

            state._fsp--;

            stream_expressions.add(expressions52.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:165:37: ( ( ASC ) | ( DESC ) )?
            int alt17=3;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==ASC) ) {
                alt17=1;
            }
            else if ( (LA17_0==DESC) ) {
                alt17=2;
            }
            switch (alt17) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:166:4: ( ASC )
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:166:4: ( ASC )
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:166:5: ASC
                    {
                    ASC53=(Token)match(input,ASC,FOLLOW_ASC_in_orderBy_11325);  
                    stream_ASC.add(ASC53);

                    orderMethod=1;

                    }


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:167:4: ( DESC )
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:167:4: ( DESC )
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:167:5: DESC
                    {
                    DESC54=(Token)match(input,DESC,FOLLOW_DESC_in_orderBy_11334);  
                    stream_DESC.add(DESC54);

                    orderMethod=2;

                    }


                    }
                    break;

            }



            // AST REWRITE
            // elements: ASC, expressions, DESC, expressions, expressions
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 168:4: -> {orderMethod==0}? ^( OrderByItem expressions )
            if (orderMethod==0) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:168:24: ^( OrderByItem expressions )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OrderByItem, "OrderByItem"), root_1);

                adaptor.addChild(root_1, stream_expressions.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 169:4: -> {orderMethod==1}? ^( OrderByItem expressions ASC )
            if (orderMethod==1) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:169:24: ^( OrderByItem expressions ASC )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OrderByItem, "OrderByItem"), root_1);

                adaptor.addChild(root_1, stream_expressions.nextTree());
                adaptor.addChild(root_1, stream_ASC.nextNode());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 170:4: -> {orderMethod==2}? ^( OrderByItem expressions DESC )
            if (orderMethod==2) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:170:24: ^( OrderByItem expressions DESC )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(OrderByItem, "OrderByItem"), root_1);

                adaptor.addChild(root_1, stream_expressions.nextTree());
                adaptor.addChild(root_1, stream_DESC.nextNode());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 171:4: ->
            {
                root_0 = null;
            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "orderBy_1"

    public static class groupBy_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "groupBy"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:173:1: groupBy : GROUP BY expressions ( COMMA expressions )* ( having )? -> ^( GroupByClause GROUP BY ( expressions )+ ( having )? ) ;
    public final HbaseSQLParser.groupBy_return groupBy() throws RecognitionException {
        HbaseSQLParser.groupBy_return retval = new HbaseSQLParser.groupBy_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token GROUP55=null;
        Token BY56=null;
        Token COMMA58=null;
        HbaseSQLParser.expressions_return expressions57 = null;

        HbaseSQLParser.expressions_return expressions59 = null;

        HbaseSQLParser.having_return having60 = null;


        CommonTree GROUP55_tree=null;
        CommonTree BY56_tree=null;
        CommonTree COMMA58_tree=null;
        RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
        RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_having=new RewriteRuleSubtreeStream(adaptor,"rule having");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:2: ( GROUP BY expressions ( COMMA expressions )* ( having )? -> ^( GroupByClause GROUP BY ( expressions )+ ( having )? ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:4: GROUP BY expressions ( COMMA expressions )* ( having )?
            {
            GROUP55=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupBy1395);  
            stream_GROUP.add(GROUP55);

            BY56=(Token)match(input,BY,FOLLOW_BY_in_groupBy1397);  
            stream_BY.add(BY56);

            pushFollow(FOLLOW_expressions_in_groupBy1399);
            expressions57=expressions();

            state._fsp--;

            stream_expressions.add(expressions57.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:25: ( COMMA expressions )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==COMMA) ) {
                    alt18=1;
                }


                switch (alt18) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:26: COMMA expressions
            	    {
            	    COMMA58=(Token)match(input,COMMA,FOLLOW_COMMA_in_groupBy1402);  
            	    stream_COMMA.add(COMMA58);

            	    pushFollow(FOLLOW_expressions_in_groupBy1404);
            	    expressions59=expressions();

            	    state._fsp--;

            	    stream_expressions.add(expressions59.getTree());

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:46: ( having )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==HAVING) ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:174:46: having
                    {
                    pushFollow(FOLLOW_having_in_groupBy1408);
                    having60=having();

                    state._fsp--;

                    stream_having.add(having60.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: expressions, BY, having, GROUP
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 175:2: -> ^( GroupByClause GROUP BY ( expressions )+ ( having )? )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:175:5: ^( GroupByClause GROUP BY ( expressions )+ ( having )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(GroupByClause, "GroupByClause"), root_1);

                adaptor.addChild(root_1, stream_GROUP.nextNode());
                adaptor.addChild(root_1, stream_BY.nextNode());
                if ( !(stream_expressions.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_expressions.hasNext() ) {
                    adaptor.addChild(root_1, stream_expressions.nextTree());

                }
                stream_expressions.reset();
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:175:43: ( having )?
                if ( stream_having.hasNext() ) {
                    adaptor.addChild(root_1, stream_having.nextTree());

                }
                stream_having.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "groupBy"

    public static class having_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "having"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:177:1: having : HAVING condition ;
    public final HbaseSQLParser.having_return having() throws RecognitionException {
        HbaseSQLParser.having_return retval = new HbaseSQLParser.having_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token HAVING61=null;
        HbaseSQLParser.condition_return condition62 = null;


        CommonTree HAVING61_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:177:7: ( HAVING condition )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:177:9: HAVING condition
            {
            root_0 = (CommonTree)adaptor.nil();

            HAVING61=(Token)match(input,HAVING,FOLLOW_HAVING_in_having1434); 
            HAVING61_tree = (CommonTree)adaptor.create(HAVING61);
            root_0 = (CommonTree)adaptor.becomeRoot(HAVING61_tree, root_0);

            pushFollow(FOLLOW_condition_in_having1437);
            condition62=condition();

            state._fsp--;

            adaptor.addChild(root_0, condition62.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "having"

    public static class update_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "update"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:178:1: update : UPDATE table SET identifier Eq expressions ( update_1 )* -> ^( UpdateClause ^( Table table ) SET ^( Column identifier ) Eq expressions ( update_1 )* ) ;
    public final HbaseSQLParser.update_return update() throws RecognitionException {
        HbaseSQLParser.update_return retval = new HbaseSQLParser.update_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token UPDATE63=null;
        Token SET65=null;
        Token Eq67=null;
        HbaseSQLParser.table_return table64 = null;

        HbaseSQLParser.identifier_return identifier66 = null;

        HbaseSQLParser.expressions_return expressions68 = null;

        HbaseSQLParser.update_1_return update_169 = null;


        CommonTree UPDATE63_tree=null;
        CommonTree SET65_tree=null;
        CommonTree Eq67_tree=null;
        RewriteRuleTokenStream stream_UPDATE=new RewriteRuleTokenStream(adaptor,"token UPDATE");
        RewriteRuleTokenStream stream_Eq=new RewriteRuleTokenStream(adaptor,"token Eq");
        RewriteRuleTokenStream stream_SET=new RewriteRuleTokenStream(adaptor,"token SET");
        RewriteRuleSubtreeStream stream_update_1=new RewriteRuleSubtreeStream(adaptor,"rule update_1");
        RewriteRuleSubtreeStream stream_table=new RewriteRuleSubtreeStream(adaptor,"rule table");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:179:2: ( UPDATE table SET identifier Eq expressions ( update_1 )* -> ^( UpdateClause ^( Table table ) SET ^( Column identifier ) Eq expressions ( update_1 )* ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:179:4: UPDATE table SET identifier Eq expressions ( update_1 )*
            {
            UPDATE63=(Token)match(input,UPDATE,FOLLOW_UPDATE_in_update1445);  
            stream_UPDATE.add(UPDATE63);

            pushFollow(FOLLOW_table_in_update1447);
            table64=table();

            state._fsp--;

            stream_table.add(table64.getTree());
            SET65=(Token)match(input,SET,FOLLOW_SET_in_update1449);  
            stream_SET.add(SET65);

            pushFollow(FOLLOW_identifier_in_update1451);
            identifier66=identifier();

            state._fsp--;

            stream_identifier.add(identifier66.getTree());
            Eq67=(Token)match(input,Eq,FOLLOW_Eq_in_update1453);  
            stream_Eq.add(Eq67);

            pushFollow(FOLLOW_expressions_in_update1455);
            expressions68=expressions();

            state._fsp--;

            stream_expressions.add(expressions68.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:179:47: ( update_1 )*
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( (LA20_0==COMMA) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:179:47: update_1
            	    {
            	    pushFollow(FOLLOW_update_1_in_update1457);
            	    update_169=update_1();

            	    state._fsp--;

            	    stream_update_1.add(update_169.getTree());

            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);



            // AST REWRITE
            // elements: update_1, Eq, identifier, expressions, table, SET
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 180:2: -> ^( UpdateClause ^( Table table ) SET ^( Column identifier ) Eq expressions ( update_1 )* )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:180:5: ^( UpdateClause ^( Table table ) SET ^( Column identifier ) Eq expressions ( update_1 )* )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UpdateClause, "UpdateClause"), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:180:20: ^( Table table )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Table, "Table"), root_2);

                adaptor.addChild(root_2, stream_table.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                adaptor.addChild(root_1, stream_SET.nextNode());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:180:39: ^( Column identifier )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Column, "Column"), root_2);

                adaptor.addChild(root_2, stream_identifier.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                adaptor.addChild(root_1, stream_Eq.nextNode());
                adaptor.addChild(root_1, stream_expressions.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:180:75: ( update_1 )*
                while ( stream_update_1.hasNext() ) {
                    adaptor.addChild(root_1, stream_update_1.nextTree());

                }
                stream_update_1.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "update"

    public static class update_1_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "update_1"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:182:1: update_1 : COMMA identifier Eq expressions -> COMMA ^( Column identifier ) Eq expressions ;
    public final HbaseSQLParser.update_1_return update_1() throws RecognitionException {
        HbaseSQLParser.update_1_return retval = new HbaseSQLParser.update_1_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token COMMA70=null;
        Token Eq72=null;
        HbaseSQLParser.identifier_return identifier71 = null;

        HbaseSQLParser.expressions_return expressions73 = null;


        CommonTree COMMA70_tree=null;
        CommonTree Eq72_tree=null;
        RewriteRuleTokenStream stream_Eq=new RewriteRuleTokenStream(adaptor,"token Eq");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:183:2: ( COMMA identifier Eq expressions -> COMMA ^( Column identifier ) Eq expressions )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:183:4: COMMA identifier Eq expressions
            {
            COMMA70=(Token)match(input,COMMA,FOLLOW_COMMA_in_update_11496);  
            stream_COMMA.add(COMMA70);

            pushFollow(FOLLOW_identifier_in_update_11498);
            identifier71=identifier();

            state._fsp--;

            stream_identifier.add(identifier71.getTree());
            Eq72=(Token)match(input,Eq,FOLLOW_Eq_in_update_11500);  
            stream_Eq.add(Eq72);

            pushFollow(FOLLOW_expressions_in_update_11502);
            expressions73=expressions();

            state._fsp--;

            stream_expressions.add(expressions73.getTree());


            // AST REWRITE
            // elements: identifier, COMMA, expressions, Eq
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 184:2: -> COMMA ^( Column identifier ) Eq expressions
            {
                adaptor.addChild(root_0, stream_COMMA.nextNode());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:184:11: ^( Column identifier )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Column, "Column"), root_1);

                adaptor.addChild(root_1, stream_identifier.nextTree());

                adaptor.addChild(root_0, root_1);
                }
                adaptor.addChild(root_0, stream_Eq.nextNode());
                adaptor.addChild(root_0, stream_expressions.nextTree());

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "update_1"

    public static class delete_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "delete"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:1: delete : DELETE ( FROM )? table -> ^( DELETE ( FROM )? ^( Table table ) ) ;
    public final HbaseSQLParser.delete_return delete() throws RecognitionException {
        HbaseSQLParser.delete_return retval = new HbaseSQLParser.delete_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token DELETE74=null;
        Token FROM75=null;
        HbaseSQLParser.table_return table76 = null;


        CommonTree DELETE74_tree=null;
        CommonTree FROM75_tree=null;
        RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
        RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
        RewriteRuleSubtreeStream stream_table=new RewriteRuleSubtreeStream(adaptor,"rule table");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:7: ( DELETE ( FROM )? table -> ^( DELETE ( FROM )? ^( Table table ) ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:9: DELETE ( FROM )? table
            {
            DELETE74=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1525);  
            stream_DELETE.add(DELETE74);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:16: ( FROM )?
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0==FROM) ) {
                alt21=1;
            }
            switch (alt21) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:16: FROM
                    {
                    FROM75=(Token)match(input,FROM,FOLLOW_FROM_in_delete1527);  
                    stream_FROM.add(FROM75);


                    }
                    break;

            }

            pushFollow(FOLLOW_table_in_delete1530);
            table76=table();

            state._fsp--;

            stream_table.add(table76.getTree());


            // AST REWRITE
            // elements: DELETE, FROM, table
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 186:28: -> ^( DELETE ( FROM )? ^( Table table ) )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:31: ^( DELETE ( FROM )? ^( Table table ) )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(stream_DELETE.nextNode(), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:40: ( FROM )?
                if ( stream_FROM.hasNext() ) {
                    adaptor.addChild(root_1, stream_FROM.nextNode());

                }
                stream_FROM.reset();
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:186:46: ^( Table table )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Table, "Table"), root_2);

                adaptor.addChild(root_2, stream_table.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "delete"

    public static class truncate_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "truncate"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:187:1: truncate : TRUNCATE table -> ^( TRUNCATE ^( Table table ) ) ;
    public final HbaseSQLParser.truncate_return truncate() throws RecognitionException {
        HbaseSQLParser.truncate_return retval = new HbaseSQLParser.truncate_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token TRUNCATE77=null;
        HbaseSQLParser.table_return table78 = null;


        CommonTree TRUNCATE77_tree=null;
        RewriteRuleTokenStream stream_TRUNCATE=new RewriteRuleTokenStream(adaptor,"token TRUNCATE");
        RewriteRuleSubtreeStream stream_table=new RewriteRuleSubtreeStream(adaptor,"rule table");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:187:9: ( TRUNCATE table -> ^( TRUNCATE ^( Table table ) ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:187:11: TRUNCATE table
            {
            TRUNCATE77=(Token)match(input,TRUNCATE,FOLLOW_TRUNCATE_in_truncate1553);  
            stream_TRUNCATE.add(TRUNCATE77);

            pushFollow(FOLLOW_table_in_truncate1555);
            table78=table();

            state._fsp--;

            stream_table.add(table78.getTree());


            // AST REWRITE
            // elements: table, TRUNCATE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 187:26: -> ^( TRUNCATE ^( Table table ) )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:187:29: ^( TRUNCATE ^( Table table ) )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(stream_TRUNCATE.nextNode(), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:187:40: ^( Table table )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Table, "Table"), root_2);

                adaptor.addChild(root_2, stream_table.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "truncate"

    public static class insert_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "insert"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:188:1: insert : INSERT INTO table LPAREN ( identifier ( COMMA identifier )* )? RPAREN ;
    public final HbaseSQLParser.insert_return insert() throws RecognitionException {
        HbaseSQLParser.insert_return retval = new HbaseSQLParser.insert_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token INSERT79=null;
        Token INTO80=null;
        Token LPAREN82=null;
        Token COMMA84=null;
        Token RPAREN86=null;
        HbaseSQLParser.table_return table81 = null;

        HbaseSQLParser.identifier_return identifier83 = null;

        HbaseSQLParser.identifier_return identifier85 = null;


        CommonTree INSERT79_tree=null;
        CommonTree INTO80_tree=null;
        CommonTree LPAREN82_tree=null;
        CommonTree COMMA84_tree=null;
        CommonTree RPAREN86_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:2: ( INSERT INTO table LPAREN ( identifier ( COMMA identifier )* )? RPAREN )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:4: INSERT INTO table LPAREN ( identifier ( COMMA identifier )* )? RPAREN
            {
            root_0 = (CommonTree)adaptor.nil();

            INSERT79=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1575); 
            INSERT79_tree = (CommonTree)adaptor.create(INSERT79);
            adaptor.addChild(root_0, INSERT79_tree);

            INTO80=(Token)match(input,INTO,FOLLOW_INTO_in_insert1577); 
            INTO80_tree = (CommonTree)adaptor.create(INTO80);
            adaptor.addChild(root_0, INTO80_tree);

            pushFollow(FOLLOW_table_in_insert1579);
            table81=table();

            state._fsp--;

            adaptor.addChild(root_0, table81.getTree());
            LPAREN82=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_insert1581); 
            LPAREN82_tree = (CommonTree)adaptor.create(LPAREN82);
            adaptor.addChild(root_0, LPAREN82_tree);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:29: ( identifier ( COMMA identifier )* )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( ((LA23_0>=QuotedIdentifier && LA23_0<=NonQuotedIdentifier)) ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:30: identifier ( COMMA identifier )*
                    {
                    pushFollow(FOLLOW_identifier_in_insert1584);
                    identifier83=identifier();

                    state._fsp--;

                    adaptor.addChild(root_0, identifier83.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:41: ( COMMA identifier )*
                    loop22:
                    do {
                        int alt22=2;
                        int LA22_0 = input.LA(1);

                        if ( (LA22_0==COMMA) ) {
                            alt22=1;
                        }


                        switch (alt22) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:189:42: COMMA identifier
                    	    {
                    	    COMMA84=(Token)match(input,COMMA,FOLLOW_COMMA_in_insert1587); 
                    	    COMMA84_tree = (CommonTree)adaptor.create(COMMA84);
                    	    adaptor.addChild(root_0, COMMA84_tree);

                    	    pushFollow(FOLLOW_identifier_in_insert1589);
                    	    identifier85=identifier();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, identifier85.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop22;
                        }
                    } while (true);


                    }
                    break;

            }

            RPAREN86=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_insert1595); 
            RPAREN86_tree = (CommonTree)adaptor.create(RPAREN86);
            adaptor.addChild(root_0, RPAREN86_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "insert"

    public static class values_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "values"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:1: values : VALUES LPAREN ( expressions ( COMMA expressions )* )? RPAREN ;
    public final HbaseSQLParser.values_return values() throws RecognitionException {
        HbaseSQLParser.values_return retval = new HbaseSQLParser.values_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token VALUES87=null;
        Token LPAREN88=null;
        Token COMMA90=null;
        Token RPAREN92=null;
        HbaseSQLParser.expressions_return expressions89 = null;

        HbaseSQLParser.expressions_return expressions91 = null;


        CommonTree VALUES87_tree=null;
        CommonTree LPAREN88_tree=null;
        CommonTree COMMA90_tree=null;
        CommonTree RPAREN92_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:7: ( VALUES LPAREN ( expressions ( COMMA expressions )* )? RPAREN )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:9: VALUES LPAREN ( expressions ( COMMA expressions )* )? RPAREN
            {
            root_0 = (CommonTree)adaptor.nil();

            VALUES87=(Token)match(input,VALUES,FOLLOW_VALUES_in_values1601); 
            VALUES87_tree = (CommonTree)adaptor.create(VALUES87);
            adaptor.addChild(root_0, VALUES87_tree);

            LPAREN88=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_values1603); 
            LPAREN88_tree = (CommonTree)adaptor.create(LPAREN88);
            adaptor.addChild(root_0, LPAREN88_tree);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:23: ( expressions ( COMMA expressions )* )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==MINUS||LA25_0==LPAREN||LA25_0==CASE||LA25_0==NULL||(LA25_0>=SUM && LA25_0<=LEN)||(LA25_0>=QuotedIdentifier && LA25_0<=UserVariable)) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:24: expressions ( COMMA expressions )*
                    {
                    pushFollow(FOLLOW_expressions_in_values1606);
                    expressions89=expressions();

                    state._fsp--;

                    adaptor.addChild(root_0, expressions89.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:36: ( COMMA expressions )*
                    loop24:
                    do {
                        int alt24=2;
                        int LA24_0 = input.LA(1);

                        if ( (LA24_0==COMMA) ) {
                            alt24=1;
                        }


                        switch (alt24) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:190:37: COMMA expressions
                    	    {
                    	    COMMA90=(Token)match(input,COMMA,FOLLOW_COMMA_in_values1609); 
                    	    COMMA90_tree = (CommonTree)adaptor.create(COMMA90);
                    	    adaptor.addChild(root_0, COMMA90_tree);

                    	    pushFollow(FOLLOW_expressions_in_values1611);
                    	    expressions91=expressions();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, expressions91.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop24;
                        }
                    } while (true);


                    }
                    break;

            }

            RPAREN92=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_values1617); 
            RPAREN92_tree = (CommonTree)adaptor.create(RPAREN92);
            adaptor.addChild(root_0, RPAREN92_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "values"

    public static class columns_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "columns"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:191:1: columns : column ( COMMA column )* -> ( column )+ ;
    public final HbaseSQLParser.columns_return columns() throws RecognitionException {
        HbaseSQLParser.columns_return retval = new HbaseSQLParser.columns_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token COMMA94=null;
        HbaseSQLParser.column_return column93 = null;

        HbaseSQLParser.column_return column95 = null;


        CommonTree COMMA94_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_column=new RewriteRuleSubtreeStream(adaptor,"rule column");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:191:8: ( column ( COMMA column )* -> ( column )+ )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:191:10: column ( COMMA column )*
            {
            pushFollow(FOLLOW_column_in_columns1623);
            column93=column();

            state._fsp--;

            stream_column.add(column93.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:191:17: ( COMMA column )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0==COMMA) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:191:19: COMMA column
            	    {
            	    COMMA94=(Token)match(input,COMMA,FOLLOW_COMMA_in_columns1627);  
            	    stream_COMMA.add(COMMA94);

            	    pushFollow(FOLLOW_column_in_columns1629);
            	    column95=column();

            	    state._fsp--;

            	    stream_column.add(column95.getTree());

            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);



            // AST REWRITE
            // elements: column
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 191:35: -> ( column )+
            {
                if ( !(stream_column.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_column.hasNext() ) {
                    adaptor.addChild(root_0, stream_column.nextTree());

                }
                stream_column.reset();

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "columns"

    public static class column_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "column"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:192:1: column : ( MUL -> ^( Column MUL ) | identifier DOT MUL -> ^( Column identifier DOT MUL ) | expressions ( columnAlias )? -> ^( Column expressions ( columnAlias )? ) );
    public final HbaseSQLParser.column_return column() throws RecognitionException {
        HbaseSQLParser.column_return retval = new HbaseSQLParser.column_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token MUL96=null;
        Token DOT98=null;
        Token MUL99=null;
        HbaseSQLParser.identifier_return identifier97 = null;

        HbaseSQLParser.expressions_return expressions100 = null;

        HbaseSQLParser.columnAlias_return columnAlias101 = null;


        CommonTree MUL96_tree=null;
        CommonTree DOT98_tree=null;
        CommonTree MUL99_tree=null;
        RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
        RewriteRuleTokenStream stream_MUL=new RewriteRuleTokenStream(adaptor,"token MUL");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        RewriteRuleSubtreeStream stream_columnAlias=new RewriteRuleSubtreeStream(adaptor,"rule columnAlias");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:193:2: ( MUL -> ^( Column MUL ) | identifier DOT MUL -> ^( Column identifier DOT MUL ) | expressions ( columnAlias )? -> ^( Column expressions ( columnAlias )? ) )
            int alt28=3;
            switch ( input.LA(1) ) {
            case MUL:
                {
                alt28=1;
                }
                break;
            case QuotedIdentifier:
                {
                int LA28_2 = input.LA(2);

                if ( (LA28_2==DOT) ) {
                    alt28=2;
                }
                else if ( (LA28_2==EOF||(LA28_2>=DIV && LA28_2<=MOD)||(LA28_2>=LPAREN && LA28_2<=RPAREN)||(LA28_2>=COMMA && LA28_2<=SEMI)||LA28_2==AS||LA28_2==DELETE||(LA28_2>=FROM && LA28_2<=GROUP)||LA28_2==INSERT||LA28_2==ORDER||LA28_2==SELECT||(LA28_2>=UNION && LA28_2<=UPDATE)||(LA28_2>=WHERE && LA28_2<=TRUNCATE)||LA28_2==CREATE||(LA28_2>=DROP && LA28_2<=NonQuotedIdentifier)) ) {
                    alt28=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 2, input);

                    throw nvae;
                }
                }
                break;
            case NonQuotedIdentifier:
                {
                int LA28_3 = input.LA(2);

                if ( (LA28_3==DOT) ) {
                    alt28=2;
                }
                else if ( (LA28_3==EOF||(LA28_3>=DIV && LA28_3<=MOD)||(LA28_3>=LPAREN && LA28_3<=RPAREN)||(LA28_3>=COMMA && LA28_3<=SEMI)||LA28_3==AS||LA28_3==DELETE||(LA28_3>=FROM && LA28_3<=GROUP)||LA28_3==INSERT||LA28_3==ORDER||LA28_3==SELECT||(LA28_3>=UNION && LA28_3<=UPDATE)||(LA28_3>=WHERE && LA28_3<=TRUNCATE)||LA28_3==CREATE||(LA28_3>=DROP && LA28_3<=NonQuotedIdentifier)) ) {
                    alt28=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 3, input);

                    throw nvae;
                }
                }
                break;
            case MINUS:
            case LPAREN:
            case CASE:
            case NULL:
            case SUM:
            case AVG:
            case MAX:
            case MIN:
            case COUNT:
            case LEN:
            case Integer:
            case StringLiteral:
            case Real:
            case UserVariable:
                {
                alt28=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;
            }

            switch (alt28) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:193:4: MUL
                    {
                    MUL96=(Token)match(input,MUL,FOLLOW_MUL_in_column1646);  
                    stream_MUL.add(MUL96);



                    // AST REWRITE
                    // elements: MUL
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 193:8: -> ^( Column MUL )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:193:11: ^( Column MUL )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Column, "Column"), root_1);

                        adaptor.addChild(root_1, stream_MUL.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:194:6: identifier DOT MUL
                    {
                    pushFollow(FOLLOW_identifier_in_column1662);
                    identifier97=identifier();

                    state._fsp--;

                    stream_identifier.add(identifier97.getTree());
                    DOT98=(Token)match(input,DOT,FOLLOW_DOT_in_column1664);  
                    stream_DOT.add(DOT98);

                    MUL99=(Token)match(input,MUL,FOLLOW_MUL_in_column1666);  
                    stream_MUL.add(MUL99);



                    // AST REWRITE
                    // elements: MUL, identifier, DOT
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 194:25: -> ^( Column identifier DOT MUL )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:194:28: ^( Column identifier DOT MUL )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Column, "Column"), root_1);

                        adaptor.addChild(root_1, stream_identifier.nextTree());
                        adaptor.addChild(root_1, stream_DOT.nextNode());
                        adaptor.addChild(root_1, stream_MUL.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:195:9: expressions ( columnAlias )?
                    {
                    pushFollow(FOLLOW_expressions_in_column1689);
                    expressions100=expressions();

                    state._fsp--;

                    stream_expressions.add(expressions100.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:195:21: ( columnAlias )?
                    int alt27=2;
                    int LA27_0 = input.LA(1);

                    if ( (LA27_0==AS||(LA27_0>=QuotedIdentifier && LA27_0<=NonQuotedIdentifier)) ) {
                        alt27=1;
                    }
                    switch (alt27) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:195:21: columnAlias
                            {
                            pushFollow(FOLLOW_columnAlias_in_column1691);
                            columnAlias101=columnAlias();

                            state._fsp--;

                            stream_columnAlias.add(columnAlias101.getTree());

                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: expressions, columnAlias
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 195:34: -> ^( Column expressions ( columnAlias )? )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:195:37: ^( Column expressions ( columnAlias )? )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Column, "Column"), root_1);

                        adaptor.addChild(root_1, stream_expressions.nextTree());
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:195:58: ( columnAlias )?
                        if ( stream_columnAlias.hasNext() ) {
                            adaptor.addChild(root_1, stream_columnAlias.nextTree());

                        }
                        stream_columnAlias.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "column"

    public static class tables_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tables"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:197:1: tables : table ( tables_0 )* ;
    public final HbaseSQLParser.tables_return tables() throws RecognitionException {
        HbaseSQLParser.tables_return retval = new HbaseSQLParser.tables_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.table_return table102 = null;

        HbaseSQLParser.tables_0_return tables_0103 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:197:7: ( table ( tables_0 )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:197:9: table ( tables_0 )*
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_table_in_tables1717);
            table102=table();

            state._fsp--;

            adaptor.addChild(root_0, table102.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:197:15: ( tables_0 )*
            loop29:
            do {
                int alt29=2;
                int LA29_0 = input.LA(1);

                if ( (LA29_0==COMMA||LA29_0==CROSS||LA29_0==INNER||LA29_0==LEFT||LA29_0==RIGHT) ) {
                    alt29=1;
                }


                switch (alt29) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:197:15: tables_0
            	    {
            	    pushFollow(FOLLOW_tables_0_in_tables1719);
            	    tables_0103=tables_0();

            	    state._fsp--;

            	    adaptor.addChild(root_0, tables_0103.getTree());

            	    }
            	    break;

            	default :
            	    break loop29;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tables"

    public static class tables_0_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tables_0"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:1: tables_0 : ( COMMA table -> table | join -> join ) ;
    public final HbaseSQLParser.tables_0_return tables_0() throws RecognitionException {
        HbaseSQLParser.tables_0_return retval = new HbaseSQLParser.tables_0_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token COMMA104=null;
        HbaseSQLParser.table_return table105 = null;

        HbaseSQLParser.join_return join106 = null;


        CommonTree COMMA104_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_table=new RewriteRuleSubtreeStream(adaptor,"rule table");
        RewriteRuleSubtreeStream stream_join=new RewriteRuleSubtreeStream(adaptor,"rule join");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:9: ( ( COMMA table -> table | join -> join ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:11: ( COMMA table -> table | join -> join )
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:11: ( COMMA table -> table | join -> join )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==COMMA) ) {
                alt30=1;
            }
            else if ( (LA30_0==CROSS||LA30_0==INNER||LA30_0==LEFT||LA30_0==RIGHT) ) {
                alt30=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:12: COMMA table
                    {
                    COMMA104=(Token)match(input,COMMA,FOLLOW_COMMA_in_tables_01727);  
                    stream_COMMA.add(COMMA104);

                    pushFollow(FOLLOW_table_in_tables_01729);
                    table105=table();

                    state._fsp--;

                    stream_table.add(table105.getTree());


                    // AST REWRITE
                    // elements: table
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 198:24: -> table
                    {
                        adaptor.addChild(root_0, stream_table.nextTree());

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:198:35: join
                    {
                    pushFollow(FOLLOW_join_in_tables_01737);
                    join106=join();

                    state._fsp--;

                    stream_join.add(join106.getTree());


                    // AST REWRITE
                    // elements: join
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 198:40: -> join
                    {
                        adaptor.addChild(root_0, stream_join.nextTree());

                    }

                    retval.tree = root_0;
                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tables_0"

    public static class table_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "table"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:199:1: table : ( subQuery ( tableAlias )? -> ^( Table subQuery ( tableAlias )? ) | identifier ( tableAlias )? -> ^( Table identifier ( tableAlias )? ) );
    public final HbaseSQLParser.table_return table() throws RecognitionException {
        HbaseSQLParser.table_return retval = new HbaseSQLParser.table_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.subQuery_return subQuery107 = null;

        HbaseSQLParser.tableAlias_return tableAlias108 = null;

        HbaseSQLParser.identifier_return identifier109 = null;

        HbaseSQLParser.tableAlias_return tableAlias110 = null;


        RewriteRuleSubtreeStream stream_subQuery=new RewriteRuleSubtreeStream(adaptor,"rule subQuery");
        RewriteRuleSubtreeStream stream_tableAlias=new RewriteRuleSubtreeStream(adaptor,"rule tableAlias");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:5: ( subQuery ( tableAlias )? -> ^( Table subQuery ( tableAlias )? ) | identifier ( tableAlias )? -> ^( Table identifier ( tableAlias )? ) )
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==LPAREN) ) {
                alt33=1;
            }
            else if ( ((LA33_0>=QuotedIdentifier && LA33_0<=NonQuotedIdentifier)) ) {
                alt33=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                throw nvae;
            }
            switch (alt33) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:7: subQuery ( tableAlias )?
                    {
                    pushFollow(FOLLOW_subQuery_in_table1754);
                    subQuery107=subQuery();

                    state._fsp--;

                    stream_subQuery.add(subQuery107.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:16: ( tableAlias )?
                    int alt31=2;
                    int LA31_0 = input.LA(1);

                    if ( (LA31_0==AS||(LA31_0>=QuotedIdentifier && LA31_0<=NonQuotedIdentifier)) ) {
                        alt31=1;
                    }
                    switch (alt31) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:16: tableAlias
                            {
                            pushFollow(FOLLOW_tableAlias_in_table1756);
                            tableAlias108=tableAlias();

                            state._fsp--;

                            stream_tableAlias.add(tableAlias108.getTree());

                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: subQuery, tableAlias
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 200:28: -> ^( Table subQuery ( tableAlias )? )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:31: ^( Table subQuery ( tableAlias )? )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Table, "Table"), root_1);

                        adaptor.addChild(root_1, stream_subQuery.nextTree());
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:200:48: ( tableAlias )?
                        if ( stream_tableAlias.hasNext() ) {
                            adaptor.addChild(root_1, stream_tableAlias.nextTree());

                        }
                        stream_tableAlias.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:201:7: identifier ( tableAlias )?
                    {
                    pushFollow(FOLLOW_identifier_in_table1777);
                    identifier109=identifier();

                    state._fsp--;

                    stream_identifier.add(identifier109.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:201:18: ( tableAlias )?
                    int alt32=2;
                    int LA32_0 = input.LA(1);

                    if ( (LA32_0==AS||(LA32_0>=QuotedIdentifier && LA32_0<=NonQuotedIdentifier)) ) {
                        alt32=1;
                    }
                    switch (alt32) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:201:18: tableAlias
                            {
                            pushFollow(FOLLOW_tableAlias_in_table1779);
                            tableAlias110=tableAlias();

                            state._fsp--;

                            stream_tableAlias.add(tableAlias110.getTree());

                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: identifier, tableAlias
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 202:7: -> ^( Table identifier ( tableAlias )? )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:202:10: ^( Table identifier ( tableAlias )? )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Table, "Table"), root_1);

                        adaptor.addChild(root_1, stream_identifier.nextTree());
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:202:29: ( tableAlias )?
                        if ( stream_tableAlias.hasNext() ) {
                            adaptor.addChild(root_1, stream_tableAlias.nextTree());

                        }
                        stream_tableAlias.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "table"

    public static class join_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "join"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:204:1: join : ( CROSS JOIN table | ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? ) JOIN table ( ON condition )? ) -> {joinType==1}? ^( JoinedTable CROSS JOIN table ) -> {joinType==2}? ^( JoinedTable INNER JOIN table ( ^( ON condition ) )? ) -> {joinType==3}? ^( JoinedTable LEFT ( OUTER )? JOIN table ( ^( ON condition ) )? ) -> {joinType==4}? ^( JoinedTable RIGHT ( OUTER )? JOIN table ( ^( ON condition ) )? ) ->;
    public final HbaseSQLParser.join_return join() throws RecognitionException {
        HbaseSQLParser.join_return retval = new HbaseSQLParser.join_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token CROSS111=null;
        Token JOIN112=null;
        Token INNER114=null;
        Token LEFT115=null;
        Token RIGHT116=null;
        Token OUTER117=null;
        Token JOIN118=null;
        Token ON120=null;
        HbaseSQLParser.table_return table113 = null;

        HbaseSQLParser.table_return table119 = null;

        HbaseSQLParser.condition_return condition121 = null;


        CommonTree CROSS111_tree=null;
        CommonTree JOIN112_tree=null;
        CommonTree INNER114_tree=null;
        CommonTree LEFT115_tree=null;
        CommonTree RIGHT116_tree=null;
        CommonTree OUTER117_tree=null;
        CommonTree JOIN118_tree=null;
        CommonTree ON120_tree=null;
        RewriteRuleTokenStream stream_OUTER=new RewriteRuleTokenStream(adaptor,"token OUTER");
        RewriteRuleTokenStream stream_ON=new RewriteRuleTokenStream(adaptor,"token ON");
        RewriteRuleTokenStream stream_RIGHT=new RewriteRuleTokenStream(adaptor,"token RIGHT");
        RewriteRuleTokenStream stream_INNER=new RewriteRuleTokenStream(adaptor,"token INNER");
        RewriteRuleTokenStream stream_CROSS=new RewriteRuleTokenStream(adaptor,"token CROSS");
        RewriteRuleTokenStream stream_JOIN=new RewriteRuleTokenStream(adaptor,"token JOIN");
        RewriteRuleTokenStream stream_LEFT=new RewriteRuleTokenStream(adaptor,"token LEFT");
        RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
        RewriteRuleSubtreeStream stream_table=new RewriteRuleSubtreeStream(adaptor,"rule table");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:205:5: ( ( CROSS JOIN table | ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? ) JOIN table ( ON condition )? ) -> {joinType==1}? ^( JoinedTable CROSS JOIN table ) -> {joinType==2}? ^( JoinedTable INNER JOIN table ( ^( ON condition ) )? ) -> {joinType==3}? ^( JoinedTable LEFT ( OUTER )? JOIN table ( ^( ON condition ) )? ) -> {joinType==4}? ^( JoinedTable RIGHT ( OUTER )? JOIN table ( ^( ON condition ) )? ) ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:205:7: ( CROSS JOIN table | ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? ) JOIN table ( ON condition )? )
            {
            int joinType=1;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:206:5: ( CROSS JOIN table | ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? ) JOIN table ( ON condition )? )
            int alt38=2;
            int LA38_0 = input.LA(1);

            if ( (LA38_0==CROSS) ) {
                alt38=1;
            }
            else if ( (LA38_0==INNER||LA38_0==LEFT||LA38_0==RIGHT) ) {
                alt38=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 38, 0, input);

                throw nvae;
            }
            switch (alt38) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:206:7: CROSS JOIN table
                    {
                    CROSS111=(Token)match(input,CROSS,FOLLOW_CROSS_in_join1823);  
                    stream_CROSS.add(CROSS111);

                    JOIN112=(Token)match(input,JOIN,FOLLOW_JOIN_in_join1825);  
                    stream_JOIN.add(JOIN112);

                    pushFollow(FOLLOW_table_in_join1827);
                    table113=table();

                    state._fsp--;

                    stream_table.add(table113.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:7: ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? ) JOIN table ( ON condition )?
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:7: ( ( INNER ) | ( ( LEFT ) | ( RIGHT ) ) ( OUTER )? )
                    int alt36=2;
                    int LA36_0 = input.LA(1);

                    if ( (LA36_0==INNER) ) {
                        alt36=1;
                    }
                    else if ( (LA36_0==LEFT||LA36_0==RIGHT) ) {
                        alt36=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 36, 0, input);

                        throw nvae;
                    }
                    switch (alt36) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:8: ( INNER )
                            {
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:8: ( INNER )
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:9: INNER
                            {
                            INNER114=(Token)match(input,INNER,FOLLOW_INNER_in_join1837);  
                            stream_INNER.add(INNER114);

                            joinType=2;

                            }


                            }
                            break;
                        case 2 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:32: ( ( LEFT ) | ( RIGHT ) ) ( OUTER )?
                            {
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:32: ( ( LEFT ) | ( RIGHT ) )
                            int alt34=2;
                            int LA34_0 = input.LA(1);

                            if ( (LA34_0==LEFT) ) {
                                alt34=1;
                            }
                            else if ( (LA34_0==RIGHT) ) {
                                alt34=2;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 34, 0, input);

                                throw nvae;
                            }
                            switch (alt34) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:33: ( LEFT )
                                    {
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:33: ( LEFT )
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:34: LEFT
                                    {
                                    LEFT115=(Token)match(input,LEFT,FOLLOW_LEFT_in_join1846);  
                                    stream_LEFT.add(LEFT115);

                                    joinType=3;

                                    }


                                    }
                                    break;
                                case 2 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:56: ( RIGHT )
                                    {
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:56: ( RIGHT )
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:57: RIGHT
                                    {
                                    RIGHT116=(Token)match(input,RIGHT,FOLLOW_RIGHT_in_join1854);  
                                    stream_RIGHT.add(RIGHT116);

                                    joinType=4;

                                    }


                                    }
                                    break;

                            }

                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:79: ( OUTER )?
                            int alt35=2;
                            int LA35_0 = input.LA(1);

                            if ( (LA35_0==OUTER) ) {
                                alt35=1;
                            }
                            switch (alt35) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:79: OUTER
                                    {
                                    OUTER117=(Token)match(input,OUTER,FOLLOW_OUTER_in_join1860);  
                                    stream_OUTER.add(OUTER117);


                                    }
                                    break;

                            }


                            }
                            break;

                    }

                    JOIN118=(Token)match(input,JOIN,FOLLOW_JOIN_in_join1864);  
                    stream_JOIN.add(JOIN118);

                    pushFollow(FOLLOW_table_in_join1866);
                    table119=table();

                    state._fsp--;

                    stream_table.add(table119.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:98: ( ON condition )?
                    int alt37=2;
                    int LA37_0 = input.LA(1);

                    if ( (LA37_0==ON) ) {
                        alt37=1;
                    }
                    switch (alt37) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:207:99: ON condition
                            {
                            ON120=(Token)match(input,ON,FOLLOW_ON_in_join1869);  
                            stream_ON.add(ON120);

                            pushFollow(FOLLOW_condition_in_join1871);
                            condition121=condition();

                            state._fsp--;

                            stream_condition.add(condition121.getTree());

                            }
                            break;

                    }


                    }
                    break;

            }



            // AST REWRITE
            // elements: OUTER, condition, ON, JOIN, JOIN, INNER, RIGHT, condition, ON, CROSS, LEFT, condition, table, JOIN, table, ON, table, table, OUTER, JOIN
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 209:7: -> {joinType==1}? ^( JoinedTable CROSS JOIN table )
            if (joinType==1) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:209:24: ^( JoinedTable CROSS JOIN table )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(JoinedTable, "JoinedTable"), root_1);

                adaptor.addChild(root_1, stream_CROSS.nextNode());
                adaptor.addChild(root_1, stream_JOIN.nextNode());
                adaptor.addChild(root_1, stream_table.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 210:7: -> {joinType==2}? ^( JoinedTable INNER JOIN table ( ^( ON condition ) )? )
            if (joinType==2) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:210:24: ^( JoinedTable INNER JOIN table ( ^( ON condition ) )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(JoinedTable, "JoinedTable"), root_1);

                adaptor.addChild(root_1, stream_INNER.nextNode());
                adaptor.addChild(root_1, stream_JOIN.nextNode());
                adaptor.addChild(root_1, stream_table.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:210:55: ( ^( ON condition ) )?
                if ( stream_condition.hasNext()||stream_ON.hasNext() ) {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:210:55: ^( ON condition )
                    {
                    CommonTree root_2 = (CommonTree)adaptor.nil();
                    root_2 = (CommonTree)adaptor.becomeRoot(stream_ON.nextNode(), root_2);

                    adaptor.addChild(root_2, stream_condition.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_condition.reset();
                stream_ON.reset();

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 211:7: -> {joinType==3}? ^( JoinedTable LEFT ( OUTER )? JOIN table ( ^( ON condition ) )? )
            if (joinType==3) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:211:24: ^( JoinedTable LEFT ( OUTER )? JOIN table ( ^( ON condition ) )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(JoinedTable, "JoinedTable"), root_1);

                adaptor.addChild(root_1, stream_LEFT.nextNode());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:211:43: ( OUTER )?
                if ( stream_OUTER.hasNext() ) {
                    adaptor.addChild(root_1, stream_OUTER.nextNode());

                }
                stream_OUTER.reset();
                adaptor.addChild(root_1, stream_JOIN.nextNode());
                adaptor.addChild(root_1, stream_table.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:211:61: ( ^( ON condition ) )?
                if ( stream_condition.hasNext()||stream_ON.hasNext() ) {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:211:61: ^( ON condition )
                    {
                    CommonTree root_2 = (CommonTree)adaptor.nil();
                    root_2 = (CommonTree)adaptor.becomeRoot(stream_ON.nextNode(), root_2);

                    adaptor.addChild(root_2, stream_condition.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_condition.reset();
                stream_ON.reset();

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 212:7: -> {joinType==4}? ^( JoinedTable RIGHT ( OUTER )? JOIN table ( ^( ON condition ) )? )
            if (joinType==4) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:212:24: ^( JoinedTable RIGHT ( OUTER )? JOIN table ( ^( ON condition ) )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(JoinedTable, "JoinedTable"), root_1);

                adaptor.addChild(root_1, stream_RIGHT.nextNode());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:212:44: ( OUTER )?
                if ( stream_OUTER.hasNext() ) {
                    adaptor.addChild(root_1, stream_OUTER.nextNode());

                }
                stream_OUTER.reset();
                adaptor.addChild(root_1, stream_JOIN.nextNode());
                adaptor.addChild(root_1, stream_table.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:212:62: ( ^( ON condition ) )?
                if ( stream_condition.hasNext()||stream_ON.hasNext() ) {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:212:62: ^( ON condition )
                    {
                    CommonTree root_2 = (CommonTree)adaptor.nil();
                    root_2 = (CommonTree)adaptor.becomeRoot(stream_ON.nextNode(), root_2);

                    adaptor.addChild(root_2, stream_condition.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_condition.reset();
                stream_ON.reset();

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 213:7: ->
            {
                root_0 = null;
            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "join"

    public static class columnAlias_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "columnAlias"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:1: columnAlias : ( AS )? identifier -> ^( Alias ( AS )? identifier ) ;
    public final HbaseSQLParser.columnAlias_return columnAlias() throws RecognitionException {
        HbaseSQLParser.columnAlias_return retval = new HbaseSQLParser.columnAlias_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token AS122=null;
        HbaseSQLParser.identifier_return identifier123 = null;


        CommonTree AS122_tree=null;
        RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:12: ( ( AS )? identifier -> ^( Alias ( AS )? identifier ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:14: ( AS )? identifier
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:14: ( AS )?
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( (LA39_0==AS) ) {
                alt39=1;
            }
            switch (alt39) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:14: AS
                    {
                    AS122=(Token)match(input,AS,FOLLOW_AS_in_columnAlias2004);  
                    stream_AS.add(AS122);


                    }
                    break;

            }

            pushFollow(FOLLOW_identifier_in_columnAlias2007);
            identifier123=identifier();

            state._fsp--;

            stream_identifier.add(identifier123.getTree());


            // AST REWRITE
            // elements: AS, identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 217:29: -> ^( Alias ( AS )? identifier )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:32: ^( Alias ( AS )? identifier )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Alias, "Alias"), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:217:40: ( AS )?
                if ( stream_AS.hasNext() ) {
                    adaptor.addChild(root_1, stream_AS.nextNode());

                }
                stream_AS.reset();
                adaptor.addChild(root_1, stream_identifier.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "columnAlias"

    public static class tableAlias_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tableAlias"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:1: tableAlias : ( AS )? identifier -> ^( Alias identifier ) ;
    public final HbaseSQLParser.tableAlias_return tableAlias() throws RecognitionException {
        HbaseSQLParser.tableAlias_return retval = new HbaseSQLParser.tableAlias_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token AS124=null;
        HbaseSQLParser.identifier_return identifier125 = null;


        CommonTree AS124_tree=null;
        RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:11: ( ( AS )? identifier -> ^( Alias identifier ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:13: ( AS )? identifier
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:13: ( AS )?
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==AS) ) {
                alt40=1;
            }
            switch (alt40) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:13: AS
                    {
                    AS124=(Token)match(input,AS,FOLLOW_AS_in_tableAlias2025);  
                    stream_AS.add(AS124);


                    }
                    break;

            }

            pushFollow(FOLLOW_identifier_in_tableAlias2028);
            identifier125=identifier();

            state._fsp--;

            stream_identifier.add(identifier125.getTree());


            // AST REWRITE
            // elements: identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 219:28: -> ^( Alias identifier )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:219:31: ^( Alias identifier )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Alias, "Alias"), root_1);

                adaptor.addChild(root_1, stream_identifier.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tableAlias"

    public static class condition_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condition"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:1: condition : subCondition ( ( AND | OR ) subCondition )* ;
    public final HbaseSQLParser.condition_return condition() throws RecognitionException {
        HbaseSQLParser.condition_return retval = new HbaseSQLParser.condition_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token AND127=null;
        Token OR128=null;
        HbaseSQLParser.subCondition_return subCondition126 = null;

        HbaseSQLParser.subCondition_return subCondition129 = null;


        CommonTree AND127_tree=null;
        CommonTree OR128_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:10: ( subCondition ( ( AND | OR ) subCondition )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:12: subCondition ( ( AND | OR ) subCondition )*
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_subCondition_in_condition2042);
            subCondition126=subCondition();

            state._fsp--;

            adaptor.addChild(root_0, subCondition126.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:25: ( ( AND | OR ) subCondition )*
            loop42:
            do {
                int alt42=2;
                int LA42_0 = input.LA(1);

                if ( (LA42_0==AND||LA42_0==OR) ) {
                    alt42=1;
                }


                switch (alt42) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:26: ( AND | OR ) subCondition
            	    {
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:26: ( AND | OR )
            	    int alt41=2;
            	    int LA41_0 = input.LA(1);

            	    if ( (LA41_0==AND) ) {
            	        alt41=1;
            	    }
            	    else if ( (LA41_0==OR) ) {
            	        alt41=2;
            	    }
            	    else {
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 41, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt41) {
            	        case 1 :
            	            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:27: AND
            	            {
            	            AND127=(Token)match(input,AND,FOLLOW_AND_in_condition2046); 
            	            AND127_tree = (CommonTree)adaptor.create(AND127);
            	            root_0 = (CommonTree)adaptor.becomeRoot(AND127_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:220:35: OR
            	            {
            	            OR128=(Token)match(input,OR,FOLLOW_OR_in_condition2052); 
            	            OR128_tree = (CommonTree)adaptor.create(OR128);
            	            root_0 = (CommonTree)adaptor.becomeRoot(OR128_tree, root_0);


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_subCondition_in_condition2057);
            	    subCondition129=subCondition();

            	    state._fsp--;

            	    adaptor.addChild(root_0, subCondition129.getTree());

            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condition"

    public static class subCondition_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "subCondition"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:221:1: subCondition : ( NOT )? ( LPAREN condition RPAREN | e= predicate ) -> {prefixNot && isGroup}? ^( NOT ^( Group condition ) ) -> {prefixNot && !isGroup}? ^( NOT $e) -> {!prefixNot && isGroup}? ^( Group condition ) -> {!prefixNot && !isGroup}? $e ->;
    public final HbaseSQLParser.subCondition_return subCondition() throws RecognitionException {
        HbaseSQLParser.subCondition_return retval = new HbaseSQLParser.subCondition_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token NOT130=null;
        Token LPAREN131=null;
        Token RPAREN133=null;
        HbaseSQLParser.predicate_return e = null;

        HbaseSQLParser.condition_return condition132 = null;


        CommonTree NOT130_tree=null;
        CommonTree LPAREN131_tree=null;
        CommonTree RPAREN133_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
        RewriteRuleSubtreeStream stream_predicate=new RewriteRuleSubtreeStream(adaptor,"rule predicate");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:221:13: ( ( NOT )? ( LPAREN condition RPAREN | e= predicate ) -> {prefixNot && isGroup}? ^( NOT ^( Group condition ) ) -> {prefixNot && !isGroup}? ^( NOT $e) -> {!prefixNot && isGroup}? ^( Group condition ) -> {!prefixNot && !isGroup}? $e ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:222:2: ( NOT )? ( LPAREN condition RPAREN | e= predicate )
            {
            boolean prefixNot=false;boolean isGroup=false;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:222:50: ( NOT )?
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( (LA43_0==NOT) ) {
                alt43=1;
            }
            switch (alt43) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:222:51: NOT
                    {
                    NOT130=(Token)match(input,NOT,FOLLOW_NOT_in_subCondition2069);  
                    stream_NOT.add(NOT130);

                    prefixNot=true;

                    }
                    break;

            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:222:75: ( LPAREN condition RPAREN | e= predicate )
            int alt44=2;
            int LA44_0 = input.LA(1);

            if ( (LA44_0==LPAREN) ) {
                int LA44_1 = input.LA(2);

                if ( (LA44_1==MINUS||LA44_1==LPAREN||LA44_1==CASE||LA44_1==EXISTS||(LA44_1>=NOT && LA44_1<=NULL)||(LA44_1>=SUM && LA44_1<=LEN)||(LA44_1>=QuotedIdentifier && LA44_1<=UserVariable)) ) {
                    alt44=1;
                }
                else if ( (LA44_1==SELECT) ) {
                    alt44=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 44, 1, input);

                    throw nvae;
                }
            }
            else if ( (LA44_0==MINUS||LA44_0==CASE||LA44_0==EXISTS||LA44_0==NULL||(LA44_0>=SUM && LA44_0<=LEN)||(LA44_0>=QuotedIdentifier && LA44_0<=UserVariable)) ) {
                alt44=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 44, 0, input);

                throw nvae;
            }
            switch (alt44) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:223:4: LPAREN condition RPAREN
                    {
                    LPAREN131=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_subCondition2080);  
                    stream_LPAREN.add(LPAREN131);

                    pushFollow(FOLLOW_condition_in_subCondition2082);
                    condition132=condition();

                    state._fsp--;

                    stream_condition.add(condition132.getTree());
                    RPAREN133=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_subCondition2084);  
                    stream_RPAREN.add(RPAREN133);

                    isGroup=true;

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:224:6: e= predicate
                    {
                    pushFollow(FOLLOW_predicate_in_subCondition2095);
                    e=predicate();

                    state._fsp--;

                    stream_predicate.add(e.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: e, condition, condition, e, NOT, NOT
            // token labels: 
            // rule labels: retval, e
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"rule e",e!=null?e.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 226:2: -> {prefixNot && isGroup}? ^( NOT ^( Group condition ) )
            if (prefixNot && isGroup) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:226:29: ^( NOT ^( Group condition ) )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(stream_NOT.nextNode(), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:226:35: ^( Group condition )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Group, "Group"), root_2);

                adaptor.addChild(root_2, stream_condition.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 227:2: -> {prefixNot && !isGroup}? ^( NOT $e)
            if (prefixNot && !isGroup) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:227:30: ^( NOT $e)
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(stream_NOT.nextNode(), root_1);

                adaptor.addChild(root_1, stream_e.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 228:2: -> {!prefixNot && isGroup}? ^( Group condition )
            if (!prefixNot && isGroup) {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:228:30: ^( Group condition )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Group, "Group"), root_1);

                adaptor.addChild(root_1, stream_condition.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 229:2: -> {!prefixNot && !isGroup}? $e
            if (!prefixNot && !isGroup) {
                adaptor.addChild(root_0, stream_e.nextTree());

            }
            else // 230:2: ->
            {
                root_0 = null;
            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "subCondition"

    public static class predicate_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "predicate"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:232:1: predicate : ( expressions ( comparisonOperator expressions -> ^( Predicate expressions comparisonOperator expressions ) | IS ( NOT )? NULL -> ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) ) | ( NOT )? IN LPAREN expressions_0 ( COMMA expressions_1 )* RPAREN -> ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* ) | ( NOT )? IN subQuery -> ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery ) | ( NOT )? BETWEEN expressions AND expressions -> ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions ) ) | EXISTS subQuery -> ^( EXISTS subQuery ) );
    public final HbaseSQLParser.predicate_return predicate() throws RecognitionException {
        HbaseSQLParser.predicate_return retval = new HbaseSQLParser.predicate_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IS137=null;
        Token NOT138=null;
        Token NULL139=null;
        Token NOT140=null;
        Token IN141=null;
        Token LPAREN142=null;
        Token COMMA144=null;
        Token RPAREN146=null;
        Token NOT147=null;
        Token IN148=null;
        Token NOT150=null;
        Token BETWEEN151=null;
        Token AND153=null;
        Token EXISTS155=null;
        HbaseSQLParser.expressions_return expressions134 = null;

        HbaseSQLParser.comparisonOperator_return comparisonOperator135 = null;

        HbaseSQLParser.expressions_return expressions136 = null;

        HbaseSQLParser.expressions_0_return expressions_0143 = null;

        HbaseSQLParser.expressions_1_return expressions_1145 = null;

        HbaseSQLParser.subQuery_return subQuery149 = null;

        HbaseSQLParser.expressions_return expressions152 = null;

        HbaseSQLParser.expressions_return expressions154 = null;

        HbaseSQLParser.subQuery_return subQuery156 = null;


        CommonTree IS137_tree=null;
        CommonTree NOT138_tree=null;
        CommonTree NULL139_tree=null;
        CommonTree NOT140_tree=null;
        CommonTree IN141_tree=null;
        CommonTree LPAREN142_tree=null;
        CommonTree COMMA144_tree=null;
        CommonTree RPAREN146_tree=null;
        CommonTree NOT147_tree=null;
        CommonTree IN148_tree=null;
        CommonTree NOT150_tree=null;
        CommonTree BETWEEN151_tree=null;
        CommonTree AND153_tree=null;
        CommonTree EXISTS155_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
        RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
        RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
        RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_IS=new RewriteRuleTokenStream(adaptor,"token IS");
        RewriteRuleTokenStream stream_BETWEEN=new RewriteRuleTokenStream(adaptor,"token BETWEEN");
        RewriteRuleTokenStream stream_NULL=new RewriteRuleTokenStream(adaptor,"token NULL");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_expressions_1=new RewriteRuleSubtreeStream(adaptor,"rule expressions_1");
        RewriteRuleSubtreeStream stream_expressions_0=new RewriteRuleSubtreeStream(adaptor,"rule expressions_0");
        RewriteRuleSubtreeStream stream_subQuery=new RewriteRuleSubtreeStream(adaptor,"rule subQuery");
        RewriteRuleSubtreeStream stream_comparisonOperator=new RewriteRuleSubtreeStream(adaptor,"rule comparisonOperator");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:233:2: ( expressions ( comparisonOperator expressions -> ^( Predicate expressions comparisonOperator expressions ) | IS ( NOT )? NULL -> ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) ) | ( NOT )? IN LPAREN expressions_0 ( COMMA expressions_1 )* RPAREN -> ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* ) | ( NOT )? IN subQuery -> ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery ) | ( NOT )? BETWEEN expressions AND expressions -> ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions ) ) | EXISTS subQuery -> ^( EXISTS subQuery ) )
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==MINUS||LA51_0==LPAREN||LA51_0==CASE||LA51_0==NULL||(LA51_0>=SUM && LA51_0<=LEN)||(LA51_0>=QuotedIdentifier && LA51_0<=UserVariable)) ) {
                alt51=1;
            }
            else if ( (LA51_0==EXISTS) ) {
                alt51=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 51, 0, input);

                throw nvae;
            }
            switch (alt51) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:233:4: expressions ( comparisonOperator expressions -> ^( Predicate expressions comparisonOperator expressions ) | IS ( NOT )? NULL -> ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) ) | ( NOT )? IN LPAREN expressions_0 ( COMMA expressions_1 )* RPAREN -> ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* ) | ( NOT )? IN subQuery -> ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery ) | ( NOT )? BETWEEN expressions AND expressions -> ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions ) )
                    {
                    pushFollow(FOLLOW_expressions_in_predicate2157);
                    expressions134=expressions();

                    state._fsp--;

                    stream_expressions.add(expressions134.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:233:16: ( comparisonOperator expressions -> ^( Predicate expressions comparisonOperator expressions ) | IS ( NOT )? NULL -> ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) ) | ( NOT )? IN LPAREN expressions_0 ( COMMA expressions_1 )* RPAREN -> ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* ) | ( NOT )? IN subQuery -> ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery ) | ( NOT )? BETWEEN expressions AND expressions -> ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions ) )
                    int alt50=5;
                    switch ( input.LA(1) ) {
                    case Eq:
                    case Neq1:
                    case Neq2:
                    case Le1:
                    case Le2:
                    case Lt:
                    case Ge1:
                    case Ge2:
                    case Gt:
                    case LIKE:
                        {
                        alt50=1;
                        }
                        break;
                    case IS:
                        {
                        alt50=2;
                        }
                        break;
                    case NOT:
                        {
                        int LA50_3 = input.LA(2);

                        if ( (LA50_3==IN) ) {
                            int LA50_4 = input.LA(3);

                            if ( (LA50_4==LPAREN) ) {
                                int LA50_6 = input.LA(4);

                                if ( (LA50_6==MINUS||LA50_6==LPAREN||LA50_6==CASE||LA50_6==NULL||(LA50_6>=SUM && LA50_6<=LEN)||(LA50_6>=QuotedIdentifier && LA50_6<=UserVariable)) ) {
                                    alt50=3;
                                }
                                else if ( (LA50_6==SELECT) ) {
                                    alt50=4;
                                }
                                else {
                                    NoViableAltException nvae =
                                        new NoViableAltException("", 50, 6, input);

                                    throw nvae;
                                }
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 50, 4, input);

                                throw nvae;
                            }
                        }
                        else if ( (LA50_3==BETWEEN) ) {
                            alt50=5;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 50, 3, input);

                            throw nvae;
                        }
                        }
                        break;
                    case IN:
                        {
                        int LA50_4 = input.LA(2);

                        if ( (LA50_4==LPAREN) ) {
                            int LA50_6 = input.LA(3);

                            if ( (LA50_6==MINUS||LA50_6==LPAREN||LA50_6==CASE||LA50_6==NULL||(LA50_6>=SUM && LA50_6<=LEN)||(LA50_6>=QuotedIdentifier && LA50_6<=UserVariable)) ) {
                                alt50=3;
                            }
                            else if ( (LA50_6==SELECT) ) {
                                alt50=4;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 50, 6, input);

                                throw nvae;
                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 50, 4, input);

                            throw nvae;
                        }
                        }
                        break;
                    case BETWEEN:
                        {
                        alt50=5;
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 50, 0, input);

                        throw nvae;
                    }

                    switch (alt50) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:233:17: comparisonOperator expressions
                            {
                            pushFollow(FOLLOW_comparisonOperator_in_predicate2160);
                            comparisonOperator135=comparisonOperator();

                            state._fsp--;

                            stream_comparisonOperator.add(comparisonOperator135.getTree());
                            pushFollow(FOLLOW_expressions_in_predicate2163);
                            expressions136=expressions();

                            state._fsp--;

                            stream_expressions.add(expressions136.getTree());


                            // AST REWRITE
                            // elements: expressions, comparisonOperator, expressions
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                            root_0 = (CommonTree)adaptor.nil();
                            // 234:4: -> ^( Predicate expressions comparisonOperator expressions )
                            {
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:234:7: ^( Predicate expressions comparisonOperator expressions )
                                {
                                CommonTree root_1 = (CommonTree)adaptor.nil();
                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Predicate, "Predicate"), root_1);

                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                adaptor.addChild(root_1, stream_comparisonOperator.nextTree());
                                adaptor.addChild(root_1, stream_expressions.nextTree());

                                adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                            }
                            break;
                        case 2 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:235:4: IS ( NOT )? NULL
                            {
                            IS137=(Token)match(input,IS,FOLLOW_IS_in_predicate2185);  
                            stream_IS.add(IS137);

                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:235:7: ( NOT )?
                            int alt45=2;
                            int LA45_0 = input.LA(1);

                            if ( (LA45_0==NOT) ) {
                                alt45=1;
                            }
                            switch (alt45) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:235:8: NOT
                                    {
                                    NOT138=(Token)match(input,NOT,FOLLOW_NOT_in_predicate2188);  
                                    stream_NOT.add(NOT138);


                                    }
                                    break;

                            }

                            NULL139=(Token)match(input,NULL,FOLLOW_NULL_in_predicate2192);  
                            stream_NULL.add(NULL139);



                            // AST REWRITE
                            // elements: IS, NULL, expressions, NOT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                            root_0 = (CommonTree)adaptor.nil();
                            // 236:4: -> ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) )
                            {
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:236:7: ^( Predicate_Is expressions ^( TextNode IS ( NOT )? NULL ) )
                                {
                                CommonTree root_1 = (CommonTree)adaptor.nil();
                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(Predicate_Is, "Predicate_Is"), root_1);

                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:236:34: ^( TextNode IS ( NOT )? NULL )
                                {
                                CommonTree root_2 = (CommonTree)adaptor.nil();
                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                                adaptor.addChild(root_2, stream_IS.nextNode());
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:236:48: ( NOT )?
                                if ( stream_NOT.hasNext() ) {
                                    adaptor.addChild(root_2, stream_NOT.nextNode());

                                }
                                stream_NOT.reset();
                                adaptor.addChild(root_2, stream_NULL.nextNode());

                                adaptor.addChild(root_1, root_2);
                                }

                                adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                            }
                            break;
                        case 3 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:237:4: ( NOT )? IN LPAREN expressions_0 ( COMMA expressions_1 )* RPAREN
                            {
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:237:4: ( NOT )?
                            int alt46=2;
                            int LA46_0 = input.LA(1);

                            if ( (LA46_0==NOT) ) {
                                alt46=1;
                            }
                            switch (alt46) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:237:4: NOT
                                    {
                                    NOT140=(Token)match(input,NOT,FOLLOW_NOT_in_predicate2222);  
                                    stream_NOT.add(NOT140);


                                    }
                                    break;

                            }

                            IN141=(Token)match(input,IN,FOLLOW_IN_in_predicate2225);  
                            stream_IN.add(IN141);

                            LPAREN142=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_predicate2227);  
                            stream_LPAREN.add(LPAREN142);

                            pushFollow(FOLLOW_expressions_0_in_predicate2229);
                            expressions_0143=expressions_0();

                            state._fsp--;

                            stream_expressions_0.add(expressions_0143.getTree());
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:237:33: ( COMMA expressions_1 )*
                            loop47:
                            do {
                                int alt47=2;
                                int LA47_0 = input.LA(1);

                                if ( (LA47_0==COMMA) ) {
                                    alt47=1;
                                }


                                switch (alt47) {
                            	case 1 :
                            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:237:34: COMMA expressions_1
                            	    {
                            	    COMMA144=(Token)match(input,COMMA,FOLLOW_COMMA_in_predicate2232);  
                            	    stream_COMMA.add(COMMA144);

                            	    pushFollow(FOLLOW_expressions_1_in_predicate2234);
                            	    expressions_1145=expressions_1();

                            	    state._fsp--;

                            	    stream_expressions_1.add(expressions_1145.getTree());

                            	    }
                            	    break;

                            	default :
                            	    break loop47;
                                }
                            } while (true);

                            RPAREN146=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_predicate2238);  
                            stream_RPAREN.add(RPAREN146);



                            // AST REWRITE
                            // elements: IN, NOT, expressions_0, IN, expressions, expressions_1
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                            root_0 = (CommonTree)adaptor.nil();
                            // 238:4: -> ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* )
                            {
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:238:7: ^( IN ^( TextNode ( NOT )? IN ) expressions expressions_0 ( expressions_1 )* )
                                {
                                CommonTree root_1 = (CommonTree)adaptor.nil();
                                root_1 = (CommonTree)adaptor.becomeRoot(stream_IN.nextNode(), root_1);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:238:12: ^( TextNode ( NOT )? IN )
                                {
                                CommonTree root_2 = (CommonTree)adaptor.nil();
                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:238:23: ( NOT )?
                                if ( stream_NOT.hasNext() ) {
                                    adaptor.addChild(root_2, stream_NOT.nextNode());

                                }
                                stream_NOT.reset();
                                adaptor.addChild(root_2, stream_IN.nextNode());

                                adaptor.addChild(root_1, root_2);
                                }
                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                adaptor.addChild(root_1, stream_expressions_0.nextTree());
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:238:58: ( expressions_1 )*
                                while ( stream_expressions_1.hasNext() ) {
                                    adaptor.addChild(root_1, stream_expressions_1.nextTree());

                                }
                                stream_expressions_1.reset();

                                adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                            }
                            break;
                        case 4 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:239:4: ( NOT )? IN subQuery
                            {
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:239:4: ( NOT )?
                            int alt48=2;
                            int LA48_0 = input.LA(1);

                            if ( (LA48_0==NOT) ) {
                                alt48=1;
                            }
                            switch (alt48) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:239:4: NOT
                                    {
                                    NOT147=(Token)match(input,NOT,FOLLOW_NOT_in_predicate2268);  
                                    stream_NOT.add(NOT147);


                                    }
                                    break;

                            }

                            IN148=(Token)match(input,IN,FOLLOW_IN_in_predicate2271);  
                            stream_IN.add(IN148);

                            pushFollow(FOLLOW_subQuery_in_predicate2273);
                            subQuery149=subQuery();

                            state._fsp--;

                            stream_subQuery.add(subQuery149.getTree());


                            // AST REWRITE
                            // elements: expressions, subQuery, NOT, IN, IN
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                            root_0 = (CommonTree)adaptor.nil();
                            // 240:4: -> ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery )
                            {
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:240:7: ^( IN ^( TextNode ( NOT )? IN ) expressions subQuery )
                                {
                                CommonTree root_1 = (CommonTree)adaptor.nil();
                                root_1 = (CommonTree)adaptor.becomeRoot(stream_IN.nextNode(), root_1);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:240:12: ^( TextNode ( NOT )? IN )
                                {
                                CommonTree root_2 = (CommonTree)adaptor.nil();
                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:240:23: ( NOT )?
                                if ( stream_NOT.hasNext() ) {
                                    adaptor.addChild(root_2, stream_NOT.nextNode());

                                }
                                stream_NOT.reset();
                                adaptor.addChild(root_2, stream_IN.nextNode());

                                adaptor.addChild(root_1, root_2);
                                }
                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                adaptor.addChild(root_1, stream_subQuery.nextTree());

                                adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                            }
                            break;
                        case 5 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:241:4: ( NOT )? BETWEEN expressions AND expressions
                            {
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:241:4: ( NOT )?
                            int alt49=2;
                            int LA49_0 = input.LA(1);

                            if ( (LA49_0==NOT) ) {
                                alt49=1;
                            }
                            switch (alt49) {
                                case 1 :
                                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:241:4: NOT
                                    {
                                    NOT150=(Token)match(input,NOT,FOLLOW_NOT_in_predicate2300);  
                                    stream_NOT.add(NOT150);


                                    }
                                    break;

                            }

                            BETWEEN151=(Token)match(input,BETWEEN,FOLLOW_BETWEEN_in_predicate2303);  
                            stream_BETWEEN.add(BETWEEN151);

                            pushFollow(FOLLOW_expressions_in_predicate2305);
                            expressions152=expressions();

                            state._fsp--;

                            stream_expressions.add(expressions152.getTree());
                            AND153=(Token)match(input,AND,FOLLOW_AND_in_predicate2307);  
                            stream_AND.add(AND153);

                            pushFollow(FOLLOW_expressions_in_predicate2309);
                            expressions154=expressions();

                            state._fsp--;

                            stream_expressions.add(expressions154.getTree());


                            // AST REWRITE
                            // elements: BETWEEN, expressions, AND, expressions, expressions, BETWEEN, NOT
                            // token labels: 
                            // rule labels: retval
                            // token list labels: 
                            // rule list labels: 
                            // wildcard labels: 
                            retval.tree = root_0;
                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                            root_0 = (CommonTree)adaptor.nil();
                            // 242:4: -> ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions )
                            {
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:242:7: ^( BETWEEN ^( TextNode ( NOT )? BETWEEN ) expressions expressions ^( TextNode AND ) expressions )
                                {
                                CommonTree root_1 = (CommonTree)adaptor.nil();
                                root_1 = (CommonTree)adaptor.becomeRoot(stream_BETWEEN.nextNode(), root_1);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:242:17: ^( TextNode ( NOT )? BETWEEN )
                                {
                                CommonTree root_2 = (CommonTree)adaptor.nil();
                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:242:28: ( NOT )?
                                if ( stream_NOT.hasNext() ) {
                                    adaptor.addChild(root_2, stream_NOT.nextNode());

                                }
                                stream_NOT.reset();
                                adaptor.addChild(root_2, stream_BETWEEN.nextNode());

                                adaptor.addChild(root_1, root_2);
                                }
                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                adaptor.addChild(root_1, stream_expressions.nextTree());
                                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:242:66: ^( TextNode AND )
                                {
                                CommonTree root_2 = (CommonTree)adaptor.nil();
                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_2);

                                adaptor.addChild(root_2, stream_AND.nextNode());

                                adaptor.addChild(root_1, root_2);
                                }
                                adaptor.addChild(root_1, stream_expressions.nextTree());

                                adaptor.addChild(root_0, root_1);
                                }

                            }

                            retval.tree = root_0;
                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:244:4: EXISTS subQuery
                    {
                    EXISTS155=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_predicate2347);  
                    stream_EXISTS.add(EXISTS155);

                    pushFollow(FOLLOW_subQuery_in_predicate2349);
                    subQuery156=subQuery();

                    state._fsp--;

                    stream_subQuery.add(subQuery156.getTree());


                    // AST REWRITE
                    // elements: subQuery, EXISTS
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 244:20: -> ^( EXISTS subQuery )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:244:23: ^( EXISTS subQuery )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot(stream_EXISTS.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_subQuery.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "predicate"

    public static class expressions_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expressions"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:247:1: expressions : expression ( mathOperator expression )* ;
    public final HbaseSQLParser.expressions_return expressions() throws RecognitionException {
        HbaseSQLParser.expressions_return retval = new HbaseSQLParser.expressions_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.expression_return expression157 = null;

        HbaseSQLParser.mathOperator_return mathOperator158 = null;

        HbaseSQLParser.expression_return expression159 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:247:12: ( expression ( mathOperator expression )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:247:14: expression ( mathOperator expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_expression_in_expressions2366);
            expression157=expression();

            state._fsp--;

            adaptor.addChild(root_0, expression157.getTree());
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:247:25: ( mathOperator expression )*
            loop52:
            do {
                int alt52=2;
                int LA52_0 = input.LA(1);

                if ( ((LA52_0>=DIV && LA52_0<=MOD)) ) {
                    alt52=1;
                }


                switch (alt52) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:247:26: mathOperator expression
            	    {
            	    pushFollow(FOLLOW_mathOperator_in_expressions2369);
            	    mathOperator158=mathOperator();

            	    state._fsp--;

            	    adaptor.addChild(root_0, mathOperator158.getTree());
            	    pushFollow(FOLLOW_expression_in_expressions2371);
            	    expression159=expression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, expression159.getTree());

            	    }
            	    break;

            	default :
            	    break loop52;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expressions"

    public static class expressions_0_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expressions_0"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:248:1: expressions_0 : expressions ;
    public final HbaseSQLParser.expressions_0_return expressions_0() throws RecognitionException {
        HbaseSQLParser.expressions_0_return retval = new HbaseSQLParser.expressions_0_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.expressions_return expressions160 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:248:14: ( expressions )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:248:16: expressions
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_expressions_in_expressions_02380);
            expressions160=expressions();

            state._fsp--;

            adaptor.addChild(root_0, expressions160.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expressions_0"

    public static class expressions_1_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expressions_1"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:249:1: expressions_1 : expressions ;
    public final HbaseSQLParser.expressions_1_return expressions_1() throws RecognitionException {
        HbaseSQLParser.expressions_1_return retval = new HbaseSQLParser.expressions_1_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.expressions_return expressions161 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:249:14: ( expressions )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:249:16: expressions
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_expressions_in_expressions_12386);
            expressions161=expressions();

            state._fsp--;

            adaptor.addChild(root_0, expressions161.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expressions_1"

    public static class expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:250:1: expression : ( function | constant | userVariable | identifier | subQuery );
    public final HbaseSQLParser.expression_return expression() throws RecognitionException {
        HbaseSQLParser.expression_return retval = new HbaseSQLParser.expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.function_return function162 = null;

        HbaseSQLParser.constant_return constant163 = null;

        HbaseSQLParser.userVariable_return userVariable164 = null;

        HbaseSQLParser.identifier_return identifier165 = null;

        HbaseSQLParser.subQuery_return subQuery166 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:251:5: ( function | constant | userVariable | identifier | subQuery )
            int alt53=5;
            switch ( input.LA(1) ) {
            case CASE:
            case SUM:
            case AVG:
            case MAX:
            case MIN:
            case COUNT:
            case LEN:
                {
                alt53=1;
                }
                break;
            case QuotedIdentifier:
                {
                int LA53_2 = input.LA(2);

                if ( (LA53_2==LPAREN) ) {
                    alt53=1;
                }
                else if ( (LA53_2==EOF||(LA53_2>=Eq && LA53_2<=MOD)||LA53_2==RPAREN||(LA53_2>=COMMA && LA53_2<=SEMI)||(LA53_2>=AND && LA53_2<=BETWEEN)||(LA53_2>=CROSS && LA53_2<=DESC)||(LA53_2>=ELSE && LA53_2<=END)||(LA53_2>=FROM && LA53_2<=INSERT)||LA53_2==IS||(LA53_2>=LEFT && LA53_2<=NOT)||(LA53_2>=OR && LA53_2<=ORDER)||(LA53_2>=RIGHT && LA53_2<=SELECT)||(LA53_2>=THEN && LA53_2<=UPDATE)||(LA53_2>=WHEN && LA53_2<=TRUNCATE)||LA53_2==CREATE||(LA53_2>=DROP && LA53_2<=NonQuotedIdentifier)) ) {
                    alt53=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 53, 2, input);

                    throw nvae;
                }
                }
                break;
            case NonQuotedIdentifier:
                {
                int LA53_3 = input.LA(2);

                if ( (LA53_3==LPAREN) ) {
                    alt53=1;
                }
                else if ( (LA53_3==EOF||(LA53_3>=Eq && LA53_3<=MOD)||LA53_3==RPAREN||(LA53_3>=COMMA && LA53_3<=SEMI)||(LA53_3>=AND && LA53_3<=BETWEEN)||(LA53_3>=CROSS && LA53_3<=DESC)||(LA53_3>=ELSE && LA53_3<=END)||(LA53_3>=FROM && LA53_3<=INSERT)||LA53_3==IS||(LA53_3>=LEFT && LA53_3<=NOT)||(LA53_3>=OR && LA53_3<=ORDER)||(LA53_3>=RIGHT && LA53_3<=SELECT)||(LA53_3>=THEN && LA53_3<=UPDATE)||(LA53_3>=WHEN && LA53_3<=TRUNCATE)||LA53_3==CREATE||(LA53_3>=DROP && LA53_3<=NonQuotedIdentifier)) ) {
                    alt53=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 53, 3, input);

                    throw nvae;
                }
                }
                break;
            case MINUS:
            case NULL:
            case Integer:
            case StringLiteral:
            case Real:
                {
                alt53=2;
                }
                break;
            case UserVariable:
                {
                alt53=3;
                }
                break;
            case LPAREN:
                {
                alt53=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 53, 0, input);

                throw nvae;
            }

            switch (alt53) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:252:6: function
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_function_in_expression2403);
                    function162=function();

                    state._fsp--;

                    adaptor.addChild(root_0, function162.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:254:8: constant
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_constant_in_expression2422);
                    constant163=constant();

                    state._fsp--;

                    adaptor.addChild(root_0, constant163.getTree());

                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:255:8: userVariable
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_userVariable_in_expression2432);
                    userVariable164=userVariable();

                    state._fsp--;

                    adaptor.addChild(root_0, userVariable164.getTree());

                    }
                    break;
                case 4 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:256:8: identifier
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_identifier_in_expression2441);
                    identifier165=identifier();

                    state._fsp--;

                    adaptor.addChild(root_0, identifier165.getTree());

                    }
                    break;
                case 5 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:257:8: subQuery
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_subQuery_in_expression2450);
                    subQuery166=subQuery();

                    state._fsp--;

                    adaptor.addChild(root_0, subQuery166.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class mathOperator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "mathOperator"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:259:1: mathOperator : ( PLUS | MINUS | MUL | DIV | MOD );
    public final HbaseSQLParser.mathOperator_return mathOperator() throws RecognitionException {
        HbaseSQLParser.mathOperator_return retval = new HbaseSQLParser.mathOperator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set167=null;

        CommonTree set167_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:259:14: ( PLUS | MINUS | MUL | DIV | MOD )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            set167=(Token)input.LT(1);
            if ( (input.LA(1)>=DIV && input.LA(1)<=MOD) ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set167));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "mathOperator"

    public static class comparisonOperator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "comparisonOperator"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:260:1: comparisonOperator : ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | LIKE );
    public final HbaseSQLParser.comparisonOperator_return comparisonOperator() throws RecognitionException {
        HbaseSQLParser.comparisonOperator_return retval = new HbaseSQLParser.comparisonOperator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set168=null;

        CommonTree set168_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:260:20: ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | LIKE )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            set168=(Token)input.LT(1);
            if ( (input.LA(1)>=Eq && input.LA(1)<=Gt)||input.LA(1)==LIKE ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set168));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "comparisonOperator"

    public static class function_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "function"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:263:1: function : ( systemFunction | userFunction );
    public final HbaseSQLParser.function_return function() throws RecognitionException {
        HbaseSQLParser.function_return retval = new HbaseSQLParser.function_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.systemFunction_return systemFunction169 = null;

        HbaseSQLParser.userFunction_return userFunction170 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:263:9: ( systemFunction | userFunction )
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( (LA54_0==CASE||(LA54_0>=SUM && LA54_0<=LEN)) ) {
                alt54=1;
            }
            else if ( ((LA54_0>=QuotedIdentifier && LA54_0<=NonQuotedIdentifier)) ) {
                alt54=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 54, 0, input);

                throw nvae;
            }
            switch (alt54) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:263:11: systemFunction
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_systemFunction_in_function2552);
                    systemFunction169=systemFunction();

                    state._fsp--;

                    adaptor.addChild(root_0, systemFunction169.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:263:28: userFunction
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_userFunction_in_function2556);
                    userFunction170=userFunction();

                    state._fsp--;

                    adaptor.addChild(root_0, userFunction170.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "function"

    public static class userFunction_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "userFunction"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:264:1: userFunction : identifier LPAREN ( expressions ( COMMA expressions_0 )* )? RPAREN -> ^( UserFunction identifier ( expressions ( expressions_0 )* )? ) ;
    public final HbaseSQLParser.userFunction_return userFunction() throws RecognitionException {
        HbaseSQLParser.userFunction_return retval = new HbaseSQLParser.userFunction_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LPAREN172=null;
        Token COMMA174=null;
        Token RPAREN176=null;
        HbaseSQLParser.identifier_return identifier171 = null;

        HbaseSQLParser.expressions_return expressions173 = null;

        HbaseSQLParser.expressions_0_return expressions_0175 = null;


        CommonTree LPAREN172_tree=null;
        CommonTree COMMA174_tree=null;
        CommonTree RPAREN176_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_expressions_0=new RewriteRuleSubtreeStream(adaptor,"rule expressions_0");
        RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:2: ( identifier LPAREN ( expressions ( COMMA expressions_0 )* )? RPAREN -> ^( UserFunction identifier ( expressions ( expressions_0 )* )? ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:4: identifier LPAREN ( expressions ( COMMA expressions_0 )* )? RPAREN
            {
            pushFollow(FOLLOW_identifier_in_userFunction2565);
            identifier171=identifier();

            state._fsp--;

            stream_identifier.add(identifier171.getTree());
            LPAREN172=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_userFunction2567);  
            stream_LPAREN.add(LPAREN172);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:22: ( expressions ( COMMA expressions_0 )* )?
            int alt56=2;
            int LA56_0 = input.LA(1);

            if ( (LA56_0==MINUS||LA56_0==LPAREN||LA56_0==CASE||LA56_0==NULL||(LA56_0>=SUM && LA56_0<=LEN)||(LA56_0>=QuotedIdentifier && LA56_0<=UserVariable)) ) {
                alt56=1;
            }
            switch (alt56) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:23: expressions ( COMMA expressions_0 )*
                    {
                    pushFollow(FOLLOW_expressions_in_userFunction2570);
                    expressions173=expressions();

                    state._fsp--;

                    stream_expressions.add(expressions173.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:35: ( COMMA expressions_0 )*
                    loop55:
                    do {
                        int alt55=2;
                        int LA55_0 = input.LA(1);

                        if ( (LA55_0==COMMA) ) {
                            alt55=1;
                        }


                        switch (alt55) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:265:36: COMMA expressions_0
                    	    {
                    	    COMMA174=(Token)match(input,COMMA,FOLLOW_COMMA_in_userFunction2573);  
                    	    stream_COMMA.add(COMMA174);

                    	    pushFollow(FOLLOW_expressions_0_in_userFunction2575);
                    	    expressions_0175=expressions_0();

                    	    state._fsp--;

                    	    stream_expressions_0.add(expressions_0175.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop55;
                        }
                    } while (true);


                    }
                    break;

            }

            RPAREN176=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_userFunction2581);  
            stream_RPAREN.add(RPAREN176);



            // AST REWRITE
            // elements: identifier, expressions, expressions_0
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 266:4: -> ^( UserFunction identifier ( expressions ( expressions_0 )* )? )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:266:7: ^( UserFunction identifier ( expressions ( expressions_0 )* )? )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UserFunction, "UserFunction"), root_1);

                adaptor.addChild(root_1, stream_identifier.nextTree());
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:266:33: ( expressions ( expressions_0 )* )?
                if ( stream_expressions.hasNext()||stream_expressions_0.hasNext() ) {
                    adaptor.addChild(root_1, stream_expressions.nextTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:266:46: ( expressions_0 )*
                    while ( stream_expressions_0.hasNext() ) {
                        adaptor.addChild(root_1, stream_expressions_0.nextTree());

                    }
                    stream_expressions_0.reset();

                }
                stream_expressions.reset();
                stream_expressions_0.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "userFunction"

    public static class systemFunction_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "systemFunction"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:268:1: systemFunction : ( fnCase | unitarySysFun | fnLen );
    public final HbaseSQLParser.systemFunction_return systemFunction() throws RecognitionException {
        HbaseSQLParser.systemFunction_return retval = new HbaseSQLParser.systemFunction_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.fnCase_return fnCase177 = null;

        HbaseSQLParser.unitarySysFun_return unitarySysFun178 = null;

        HbaseSQLParser.fnLen_return fnLen179 = null;



        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:268:15: ( fnCase | unitarySysFun | fnLen )
            int alt57=3;
            switch ( input.LA(1) ) {
            case CASE:
                {
                alt57=1;
                }
                break;
            case SUM:
            case AVG:
            case MAX:
            case MIN:
            case COUNT:
                {
                alt57=2;
                }
                break;
            case LEN:
                {
                alt57=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 57, 0, input);

                throw nvae;
            }

            switch (alt57) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:268:17: fnCase
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_fnCase_in_systemFunction2608);
                    fnCase177=fnCase();

                    state._fsp--;

                    adaptor.addChild(root_0, fnCase177.getTree());

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:268:26: unitarySysFun
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_unitarySysFun_in_systemFunction2612);
                    unitarySysFun178=unitarySysFun();

                    state._fsp--;

                    adaptor.addChild(root_0, unitarySysFun178.getTree());

                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:268:42: fnLen
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_fnLen_in_systemFunction2616);
                    fnLen179=fnLen();

                    state._fsp--;

                    adaptor.addChild(root_0, fnLen179.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "systemFunction"

    public static class fnCase_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "fnCase"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:271:1: fnCase : CASE ( expressions ( WHEN expressions THEN expressions )+ | ( WHEN condition THEN expressions )+ ) ( ELSE expressions )? END ;
    public final HbaseSQLParser.fnCase_return fnCase() throws RecognitionException {
        HbaseSQLParser.fnCase_return retval = new HbaseSQLParser.fnCase_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token CASE180=null;
        Token WHEN182=null;
        Token THEN184=null;
        Token WHEN186=null;
        Token THEN188=null;
        Token ELSE190=null;
        Token END192=null;
        HbaseSQLParser.expressions_return expressions181 = null;

        HbaseSQLParser.expressions_return expressions183 = null;

        HbaseSQLParser.expressions_return expressions185 = null;

        HbaseSQLParser.condition_return condition187 = null;

        HbaseSQLParser.expressions_return expressions189 = null;

        HbaseSQLParser.expressions_return expressions191 = null;


        CommonTree CASE180_tree=null;
        CommonTree WHEN182_tree=null;
        CommonTree THEN184_tree=null;
        CommonTree WHEN186_tree=null;
        CommonTree THEN188_tree=null;
        CommonTree ELSE190_tree=null;
        CommonTree END192_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:272:5: ( CASE ( expressions ( WHEN expressions THEN expressions )+ | ( WHEN condition THEN expressions )+ ) ( ELSE expressions )? END )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:272:7: CASE ( expressions ( WHEN expressions THEN expressions )+ | ( WHEN condition THEN expressions )+ ) ( ELSE expressions )? END
            {
            root_0 = (CommonTree)adaptor.nil();

            CASE180=(Token)match(input,CASE,FOLLOW_CASE_in_fnCase2629); 
            CASE180_tree = (CommonTree)adaptor.create(CASE180);
            root_0 = (CommonTree)adaptor.becomeRoot(CASE180_tree, root_0);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:272:13: ( expressions ( WHEN expressions THEN expressions )+ | ( WHEN condition THEN expressions )+ )
            int alt60=2;
            int LA60_0 = input.LA(1);

            if ( (LA60_0==MINUS||LA60_0==LPAREN||LA60_0==CASE||LA60_0==NULL||(LA60_0>=SUM && LA60_0<=LEN)||(LA60_0>=QuotedIdentifier && LA60_0<=UserVariable)) ) {
                alt60=1;
            }
            else if ( (LA60_0==WHEN) ) {
                alt60=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 60, 0, input);

                throw nvae;
            }
            switch (alt60) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:273:11: expressions ( WHEN expressions THEN expressions )+
                    {
                    pushFollow(FOLLOW_expressions_in_fnCase2644);
                    expressions181=expressions();

                    state._fsp--;

                    adaptor.addChild(root_0, expressions181.getTree());
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:273:23: ( WHEN expressions THEN expressions )+
                    int cnt58=0;
                    loop58:
                    do {
                        int alt58=2;
                        int LA58_0 = input.LA(1);

                        if ( (LA58_0==WHEN) ) {
                            alt58=1;
                        }


                        switch (alt58) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:273:24: WHEN expressions THEN expressions
                    	    {
                    	    WHEN182=(Token)match(input,WHEN,FOLLOW_WHEN_in_fnCase2647); 
                    	    WHEN182_tree = (CommonTree)adaptor.create(WHEN182);
                    	    adaptor.addChild(root_0, WHEN182_tree);

                    	    pushFollow(FOLLOW_expressions_in_fnCase2649);
                    	    expressions183=expressions();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, expressions183.getTree());
                    	    THEN184=(Token)match(input,THEN,FOLLOW_THEN_in_fnCase2651); 
                    	    THEN184_tree = (CommonTree)adaptor.create(THEN184);
                    	    adaptor.addChild(root_0, THEN184_tree);

                    	    pushFollow(FOLLOW_expressions_in_fnCase2653);
                    	    expressions185=expressions();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, expressions185.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt58 >= 1 ) break loop58;
                                EarlyExitException eee =
                                    new EarlyExitException(58, input);
                                throw eee;
                        }
                        cnt58++;
                    } while (true);


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:274:11: ( WHEN condition THEN expressions )+
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:274:11: ( WHEN condition THEN expressions )+
                    int cnt59=0;
                    loop59:
                    do {
                        int alt59=2;
                        int LA59_0 = input.LA(1);

                        if ( (LA59_0==WHEN) ) {
                            alt59=1;
                        }


                        switch (alt59) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:274:12: WHEN condition THEN expressions
                    	    {
                    	    WHEN186=(Token)match(input,WHEN,FOLLOW_WHEN_in_fnCase2668); 
                    	    WHEN186_tree = (CommonTree)adaptor.create(WHEN186);
                    	    adaptor.addChild(root_0, WHEN186_tree);

                    	    pushFollow(FOLLOW_condition_in_fnCase2670);
                    	    condition187=condition();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, condition187.getTree());
                    	    THEN188=(Token)match(input,THEN,FOLLOW_THEN_in_fnCase2672); 
                    	    THEN188_tree = (CommonTree)adaptor.create(THEN188);
                    	    adaptor.addChild(root_0, THEN188_tree);

                    	    pushFollow(FOLLOW_expressions_in_fnCase2674);
                    	    expressions189=expressions();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, expressions189.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt59 >= 1 ) break loop59;
                                EarlyExitException eee =
                                    new EarlyExitException(59, input);
                                throw eee;
                        }
                        cnt59++;
                    } while (true);


                    }
                    break;

            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:276:5: ( ELSE expressions )?
            int alt61=2;
            int LA61_0 = input.LA(1);

            if ( (LA61_0==ELSE) ) {
                alt61=1;
            }
            switch (alt61) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:276:6: ELSE expressions
                    {
                    ELSE190=(Token)match(input,ELSE,FOLLOW_ELSE_in_fnCase2697); 
                    ELSE190_tree = (CommonTree)adaptor.create(ELSE190);
                    adaptor.addChild(root_0, ELSE190_tree);

                    pushFollow(FOLLOW_expressions_in_fnCase2699);
                    expressions191=expressions();

                    state._fsp--;

                    adaptor.addChild(root_0, expressions191.getTree());

                    }
                    break;

            }

            END192=(Token)match(input,END,FOLLOW_END_in_fnCase2703); 
            END192_tree = (CommonTree)adaptor.create(END192);
            adaptor.addChild(root_0, END192_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "fnCase"

    public static class fnLen_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "fnLen"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:278:1: fnLen : LEN LPAREN expressions RPAREN -> ^( LEN expressions ) ;
    public final HbaseSQLParser.fnLen_return fnLen() throws RecognitionException {
        HbaseSQLParser.fnLen_return retval = new HbaseSQLParser.fnLen_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LEN193=null;
        Token LPAREN194=null;
        Token RPAREN196=null;
        HbaseSQLParser.expressions_return expressions195 = null;


        CommonTree LEN193_tree=null;
        CommonTree LPAREN194_tree=null;
        CommonTree RPAREN196_tree=null;
        RewriteRuleTokenStream stream_LEN=new RewriteRuleTokenStream(adaptor,"token LEN");
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:279:2: ( LEN LPAREN expressions RPAREN -> ^( LEN expressions ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:279:4: LEN LPAREN expressions RPAREN
            {
            LEN193=(Token)match(input,LEN,FOLLOW_LEN_in_fnLen2716);  
            stream_LEN.add(LEN193);

            LPAREN194=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_fnLen2718);  
            stream_LPAREN.add(LPAREN194);

            pushFollow(FOLLOW_expressions_in_fnLen2720);
            expressions195=expressions();

            state._fsp--;

            stream_expressions.add(expressions195.getTree());
            RPAREN196=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_fnLen2722);  
            stream_RPAREN.add(RPAREN196);



            // AST REWRITE
            // elements: LEN, expressions
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 280:4: -> ^( LEN expressions )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:280:7: ^( LEN expressions )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(stream_LEN.nextNode(), root_1);

                adaptor.addChild(root_1, stream_expressions.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "fnLen"

    public static class unitarySysFun_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unitarySysFun"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:1: unitarySysFun : ( SUM | AVG | MAX | MIN | COUNT ) unitarySysFun_0 ;
    public final HbaseSQLParser.unitarySysFun_return unitarySysFun() throws RecognitionException {
        HbaseSQLParser.unitarySysFun_return retval = new HbaseSQLParser.unitarySysFun_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token SUM197=null;
        Token AVG198=null;
        Token MAX199=null;
        Token MIN200=null;
        Token COUNT201=null;
        HbaseSQLParser.unitarySysFun_0_return unitarySysFun_0202 = null;


        CommonTree SUM197_tree=null;
        CommonTree AVG198_tree=null;
        CommonTree MAX199_tree=null;
        CommonTree MIN200_tree=null;
        CommonTree COUNT201_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:14: ( ( SUM | AVG | MAX | MIN | COUNT ) unitarySysFun_0 )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:16: ( SUM | AVG | MAX | MIN | COUNT ) unitarySysFun_0
            {
            root_0 = (CommonTree)adaptor.nil();

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:16: ( SUM | AVG | MAX | MIN | COUNT )
            int alt62=5;
            switch ( input.LA(1) ) {
            case SUM:
                {
                alt62=1;
                }
                break;
            case AVG:
                {
                alt62=2;
                }
                break;
            case MAX:
                {
                alt62=3;
                }
                break;
            case MIN:
                {
                alt62=4;
                }
                break;
            case COUNT:
                {
                alt62=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 62, 0, input);

                throw nvae;
            }

            switch (alt62) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:17: SUM
                    {
                    SUM197=(Token)match(input,SUM,FOLLOW_SUM_in_unitarySysFun2742); 
                    SUM197_tree = (CommonTree)adaptor.create(SUM197);
                    root_0 = (CommonTree)adaptor.becomeRoot(SUM197_tree, root_0);


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:24: AVG
                    {
                    AVG198=(Token)match(input,AVG,FOLLOW_AVG_in_unitarySysFun2747); 
                    AVG198_tree = (CommonTree)adaptor.create(AVG198);
                    root_0 = (CommonTree)adaptor.becomeRoot(AVG198_tree, root_0);


                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:31: MAX
                    {
                    MAX199=(Token)match(input,MAX,FOLLOW_MAX_in_unitarySysFun2752); 
                    MAX199_tree = (CommonTree)adaptor.create(MAX199);
                    root_0 = (CommonTree)adaptor.becomeRoot(MAX199_tree, root_0);


                    }
                    break;
                case 4 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:38: MIN
                    {
                    MIN200=(Token)match(input,MIN,FOLLOW_MIN_in_unitarySysFun2757); 
                    MIN200_tree = (CommonTree)adaptor.create(MIN200);
                    root_0 = (CommonTree)adaptor.becomeRoot(MIN200_tree, root_0);


                    }
                    break;
                case 5 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:282:45: COUNT
                    {
                    COUNT201=(Token)match(input,COUNT,FOLLOW_COUNT_in_unitarySysFun2762); 
                    COUNT201_tree = (CommonTree)adaptor.create(COUNT201);
                    root_0 = (CommonTree)adaptor.becomeRoot(COUNT201_tree, root_0);


                    }
                    break;

            }

            pushFollow(FOLLOW_unitarySysFun_0_in_unitarySysFun2766);
            unitarySysFun_0202=unitarySysFun_0();

            state._fsp--;

            adaptor.addChild(root_0, unitarySysFun_0202.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "unitarySysFun"

    public static class unitarySysFun_0_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unitarySysFun_0"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:283:1: unitarySysFun_0 : LPAREN ( ( MUL ) | ( expressions ) )? RPAREN -> {paramType==1}? -> {paramType==2}? MUL -> {paramType==3}? expressions ->;
    public final HbaseSQLParser.unitarySysFun_0_return unitarySysFun_0() throws RecognitionException {
        HbaseSQLParser.unitarySysFun_0_return retval = new HbaseSQLParser.unitarySysFun_0_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LPAREN203=null;
        Token MUL204=null;
        Token RPAREN206=null;
        HbaseSQLParser.expressions_return expressions205 = null;


        CommonTree LPAREN203_tree=null;
        CommonTree MUL204_tree=null;
        CommonTree RPAREN206_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_MUL=new RewriteRuleTokenStream(adaptor,"token MUL");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_expressions=new RewriteRuleSubtreeStream(adaptor,"rule expressions");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:2: ( LPAREN ( ( MUL ) | ( expressions ) )? RPAREN -> {paramType==1}? -> {paramType==2}? MUL -> {paramType==3}? expressions ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:4: LPAREN ( ( MUL ) | ( expressions ) )? RPAREN
            {
            int paramType=1;
            LPAREN203=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_unitarySysFun_02776);  
            stream_LPAREN.add(LPAREN203);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:30: ( ( MUL ) | ( expressions ) )?
            int alt63=3;
            int LA63_0 = input.LA(1);

            if ( (LA63_0==MUL) ) {
                alt63=1;
            }
            else if ( (LA63_0==MINUS||LA63_0==LPAREN||LA63_0==CASE||LA63_0==NULL||(LA63_0>=SUM && LA63_0<=LEN)||(LA63_0>=QuotedIdentifier && LA63_0<=UserVariable)) ) {
                alt63=2;
            }
            switch (alt63) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:31: ( MUL )
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:31: ( MUL )
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:32: MUL
                    {
                    MUL204=(Token)match(input,MUL,FOLLOW_MUL_in_unitarySysFun_02780);  
                    stream_MUL.add(MUL204);

                    paramType=2;

                    }


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:54: ( expressions )
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:54: ( expressions )
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:284:55: expressions
                    {
                    pushFollow(FOLLOW_expressions_in_unitarySysFun_02788);
                    expressions205=expressions();

                    state._fsp--;

                    stream_expressions.add(expressions205.getTree());
                    paramType=3;

                    }


                    }
                    break;

            }

            RPAREN206=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_unitarySysFun_02795);  
            stream_RPAREN.add(RPAREN206);



            // AST REWRITE
            // elements: expressions, MUL
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 285:4: -> {paramType==1}?
            if (paramType==1) {
                root_0 = null;
            }
            else // 286:4: -> {paramType==2}? MUL
            if (paramType==2) {
                adaptor.addChild(root_0, stream_MUL.nextNode());

            }
            else // 287:4: -> {paramType==3}? expressions
            if (paramType==3) {
                adaptor.addChild(root_0, stream_expressions.nextTree());

            }
            else // 288:4: ->
            {
                root_0 = null;
            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "unitarySysFun_0"

    public static class identifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "identifier"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:294:1: identifier : ( QuotedIdentifier -> | NonQuotedIdentifier ->);
    public final HbaseSQLParser.identifier_return identifier() throws RecognitionException {
        HbaseSQLParser.identifier_return retval = new HbaseSQLParser.identifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token QuotedIdentifier207=null;
        Token NonQuotedIdentifier208=null;

        CommonTree QuotedIdentifier207_tree=null;
        CommonTree NonQuotedIdentifier208_tree=null;
        RewriteRuleTokenStream stream_NonQuotedIdentifier=new RewriteRuleTokenStream(adaptor,"token NonQuotedIdentifier");
        RewriteRuleTokenStream stream_QuotedIdentifier=new RewriteRuleTokenStream(adaptor,"token QuotedIdentifier");

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:295:2: ( QuotedIdentifier -> | NonQuotedIdentifier ->)
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( (LA64_0==QuotedIdentifier) ) {
                alt64=1;
            }
            else if ( (LA64_0==NonQuotedIdentifier) ) {
                alt64=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 64, 0, input);

                throw nvae;
            }
            switch (alt64) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:295:4: QuotedIdentifier
                    {
                    QuotedIdentifier207=(Token)match(input,QuotedIdentifier,FOLLOW_QuotedIdentifier_in_identifier2836);  
                    stream_QuotedIdentifier.add(QuotedIdentifier207);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 295:21: ->
                    {
                        adaptor.addChild(root_0, new Identifier(QuotedIdentifier207));

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:296:4: NonQuotedIdentifier
                    {
                    NonQuotedIdentifier208=(Token)match(input,NonQuotedIdentifier,FOLLOW_NonQuotedIdentifier_in_identifier2845);  
                    stream_NonQuotedIdentifier.add(NonQuotedIdentifier208);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 296:24: ->
                    {
                        adaptor.addChild(root_0, new Identifier(NonQuotedIdentifier208));

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "identifier"

    public static class datatype_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "datatype"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:298:1: datatype : ( datatypeNParam -> ^( DataType datatypeNParam ) | datatypeOneParam -> ^( DataType datatypeOneParam ) | datatypeNoParam -> ^( DataType datatypeNoParam ) );
    public final HbaseSQLParser.datatype_return datatype() throws RecognitionException {
        HbaseSQLParser.datatype_return retval = new HbaseSQLParser.datatype_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        HbaseSQLParser.datatypeNParam_return datatypeNParam209 = null;

        HbaseSQLParser.datatypeOneParam_return datatypeOneParam210 = null;

        HbaseSQLParser.datatypeNoParam_return datatypeNoParam211 = null;


        RewriteRuleSubtreeStream stream_datatypeNoParam=new RewriteRuleSubtreeStream(adaptor,"rule datatypeNoParam");
        RewriteRuleSubtreeStream stream_datatypeOneParam=new RewriteRuleSubtreeStream(adaptor,"rule datatypeOneParam");
        RewriteRuleSubtreeStream stream_datatypeNParam=new RewriteRuleSubtreeStream(adaptor,"rule datatypeNParam");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:299:2: ( datatypeNParam -> ^( DataType datatypeNParam ) | datatypeOneParam -> ^( DataType datatypeOneParam ) | datatypeNoParam -> ^( DataType datatypeNoParam ) )
            int alt65=3;
            switch ( input.LA(1) ) {
            case DECIMAL:
                {
                alt65=1;
                }
                break;
            case CHAR:
            case NCHAR:
            case VARCHAR:
            case NVARCHAR:
            case TEXT:
            case NTEXT:
            case BINARY:
                {
                alt65=2;
                }
                break;
            case DATETIME:
            case INT:
                {
                alt65=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 65, 0, input);

                throw nvae;
            }

            switch (alt65) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:299:4: datatypeNParam
                    {
                    pushFollow(FOLLOW_datatypeNParam_in_datatype2859);
                    datatypeNParam209=datatypeNParam();

                    state._fsp--;

                    stream_datatypeNParam.add(datatypeNParam209.getTree());


                    // AST REWRITE
                    // elements: datatypeNParam
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 299:19: -> ^( DataType datatypeNParam )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:299:22: ^( DataType datatypeNParam )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DataType, "DataType"), root_1);

                        adaptor.addChild(root_1, stream_datatypeNParam.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:300:4: datatypeOneParam
                    {
                    pushFollow(FOLLOW_datatypeOneParam_in_datatype2872);
                    datatypeOneParam210=datatypeOneParam();

                    state._fsp--;

                    stream_datatypeOneParam.add(datatypeOneParam210.getTree());


                    // AST REWRITE
                    // elements: datatypeOneParam
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 300:21: -> ^( DataType datatypeOneParam )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:300:24: ^( DataType datatypeOneParam )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DataType, "DataType"), root_1);

                        adaptor.addChild(root_1, stream_datatypeOneParam.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:301:4: datatypeNoParam
                    {
                    pushFollow(FOLLOW_datatypeNoParam_in_datatype2885);
                    datatypeNoParam211=datatypeNoParam();

                    state._fsp--;

                    stream_datatypeNoParam.add(datatypeNoParam211.getTree());


                    // AST REWRITE
                    // elements: datatypeNoParam
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 301:20: -> ^( DataType datatypeNoParam )
                    {
                        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:301:23: ^( DataType datatypeNoParam )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DataType, "DataType"), root_1);

                        adaptor.addChild(root_1, stream_datatypeNoParam.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "datatype"

    public static class datatypeNoParam_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "datatypeNoParam"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:303:1: datatypeNoParam : ( INT | DATETIME );
    public final HbaseSQLParser.datatypeNoParam_return datatypeNoParam() throws RecognitionException {
        HbaseSQLParser.datatypeNoParam_return retval = new HbaseSQLParser.datatypeNoParam_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set212=null;

        CommonTree set212_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:303:16: ( INT | DATETIME )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            set212=(Token)input.LT(1);
            if ( (input.LA(1)>=DATETIME && input.LA(1)<=INT) ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set212));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "datatypeNoParam"

    public static class datatypeOneParam_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "datatypeOneParam"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:304:1: datatypeOneParam : ( CHAR | NCHAR | VARCHAR | NVARCHAR | TEXT | NTEXT | BINARY ) ( LPAREN Integer RPAREN )? ;
    public final HbaseSQLParser.datatypeOneParam_return datatypeOneParam() throws RecognitionException {
        HbaseSQLParser.datatypeOneParam_return retval = new HbaseSQLParser.datatypeOneParam_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set213=null;
        Token LPAREN214=null;
        Token Integer215=null;
        Token RPAREN216=null;

        CommonTree set213_tree=null;
        CommonTree LPAREN214_tree=null;
        CommonTree Integer215_tree=null;
        CommonTree RPAREN216_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:305:2: ( ( CHAR | NCHAR | VARCHAR | NVARCHAR | TEXT | NTEXT | BINARY ) ( LPAREN Integer RPAREN )? )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:305:4: ( CHAR | NCHAR | VARCHAR | NVARCHAR | TEXT | NTEXT | BINARY ) ( LPAREN Integer RPAREN )?
            {
            root_0 = (CommonTree)adaptor.nil();

            set213=(Token)input.LT(1);
            if ( (input.LA(1)>=CHAR && input.LA(1)<=NTEXT)||input.LA(1)==BINARY ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set213));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:306:4: ( LPAREN Integer RPAREN )?
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( (LA66_0==LPAREN) ) {
                alt66=1;
            }
            switch (alt66) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:306:5: LPAREN Integer RPAREN
                    {
                    LPAREN214=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_datatypeOneParam2946); 
                    LPAREN214_tree = (CommonTree)adaptor.create(LPAREN214);
                    adaptor.addChild(root_0, LPAREN214_tree);

                    Integer215=(Token)match(input,Integer,FOLLOW_Integer_in_datatypeOneParam2948); 
                    Integer215_tree = (CommonTree)adaptor.create(Integer215);
                    adaptor.addChild(root_0, Integer215_tree);

                    RPAREN216=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_datatypeOneParam2950); 
                    RPAREN216_tree = (CommonTree)adaptor.create(RPAREN216);
                    adaptor.addChild(root_0, RPAREN216_tree);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "datatypeOneParam"

    public static class datatypeNParam_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "datatypeNParam"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:308:1: datatypeNParam : ( DECIMAL ) ( LPAREN Integer ( COMMA Integer )? RPAREN )? ;
    public final HbaseSQLParser.datatypeNParam_return datatypeNParam() throws RecognitionException {
        HbaseSQLParser.datatypeNParam_return retval = new HbaseSQLParser.datatypeNParam_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token DECIMAL217=null;
        Token LPAREN218=null;
        Token Integer219=null;
        Token COMMA220=null;
        Token Integer221=null;
        Token RPAREN222=null;

        CommonTree DECIMAL217_tree=null;
        CommonTree LPAREN218_tree=null;
        CommonTree Integer219_tree=null;
        CommonTree COMMA220_tree=null;
        CommonTree Integer221_tree=null;
        CommonTree RPAREN222_tree=null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:309:2: ( ( DECIMAL ) ( LPAREN Integer ( COMMA Integer )? RPAREN )? )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:309:4: ( DECIMAL ) ( LPAREN Integer ( COMMA Integer )? RPAREN )?
            {
            root_0 = (CommonTree)adaptor.nil();

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:309:4: ( DECIMAL )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:309:5: DECIMAL
            {
            DECIMAL217=(Token)match(input,DECIMAL,FOLLOW_DECIMAL_in_datatypeNParam2963); 
            DECIMAL217_tree = (CommonTree)adaptor.create(DECIMAL217);
            adaptor.addChild(root_0, DECIMAL217_tree);


            }

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:310:4: ( LPAREN Integer ( COMMA Integer )? RPAREN )?
            int alt68=2;
            int LA68_0 = input.LA(1);

            if ( (LA68_0==LPAREN) ) {
                alt68=1;
            }
            switch (alt68) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:310:5: LPAREN Integer ( COMMA Integer )? RPAREN
                    {
                    LPAREN218=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_datatypeNParam2970); 
                    LPAREN218_tree = (CommonTree)adaptor.create(LPAREN218);
                    adaptor.addChild(root_0, LPAREN218_tree);

                    Integer219=(Token)match(input,Integer,FOLLOW_Integer_in_datatypeNParam2972); 
                    Integer219_tree = (CommonTree)adaptor.create(Integer219);
                    adaptor.addChild(root_0, Integer219_tree);

                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:310:20: ( COMMA Integer )?
                    int alt67=2;
                    int LA67_0 = input.LA(1);

                    if ( (LA67_0==COMMA) ) {
                        alt67=1;
                    }
                    switch (alt67) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:310:21: COMMA Integer
                            {
                            COMMA220=(Token)match(input,COMMA,FOLLOW_COMMA_in_datatypeNParam2975); 
                            COMMA220_tree = (CommonTree)adaptor.create(COMMA220);
                            adaptor.addChild(root_0, COMMA220_tree);

                            Integer221=(Token)match(input,Integer,FOLLOW_Integer_in_datatypeNParam2977); 
                            Integer221_tree = (CommonTree)adaptor.create(Integer221);
                            adaptor.addChild(root_0, Integer221_tree);


                            }
                            break;

                    }

                    RPAREN222=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_datatypeNParam2981); 
                    RPAREN222_tree = (CommonTree)adaptor.create(RPAREN222);
                    adaptor.addChild(root_0, RPAREN222_tree);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "datatypeNParam"

    public static class constant_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constant"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:313:1: constant : (e1= constant_real -> | e2= constant_int -> | NULL -> | StringLiteral ->);
    public final HbaseSQLParser.constant_return constant() throws RecognitionException {
        HbaseSQLParser.constant_return retval = new HbaseSQLParser.constant_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token NULL223=null;
        Token StringLiteral224=null;
        HbaseSQLParser.constant_real_return e1 = null;

        HbaseSQLParser.constant_int_return e2 = null;


        CommonTree NULL223_tree=null;
        CommonTree StringLiteral224_tree=null;
        RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
        RewriteRuleTokenStream stream_NULL=new RewriteRuleTokenStream(adaptor,"token NULL");
        RewriteRuleSubtreeStream stream_constant_int=new RewriteRuleSubtreeStream(adaptor,"rule constant_int");
        RewriteRuleSubtreeStream stream_constant_real=new RewriteRuleSubtreeStream(adaptor,"rule constant_real");
        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:314:2: (e1= constant_real -> | e2= constant_int -> | NULL -> | StringLiteral ->)
            int alt69=4;
            switch ( input.LA(1) ) {
            case MINUS:
                {
                int LA69_1 = input.LA(2);

                if ( (LA69_1==Real) ) {
                    alt69=1;
                }
                else if ( (LA69_1==Integer) ) {
                    alt69=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 69, 1, input);

                    throw nvae;
                }
                }
                break;
            case Real:
                {
                alt69=1;
                }
                break;
            case Integer:
                {
                alt69=2;
                }
                break;
            case NULL:
                {
                alt69=3;
                }
                break;
            case StringLiteral:
                {
                alt69=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 69, 0, input);

                throw nvae;
            }

            switch (alt69) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:314:4: e1= constant_real
                    {
                    pushFollow(FOLLOW_constant_real_in_constant2997);
                    e1=constant_real();

                    state._fsp--;

                    stream_constant_real.add(e1.getTree());


                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 314:21: ->
                    {
                        adaptor.addChild(root_0, new Constant(e1.tree));

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:315:4: e2= constant_int
                    {
                    pushFollow(FOLLOW_constant_int_in_constant3008);
                    e2=constant_int();

                    state._fsp--;

                    stream_constant_int.add(e2.getTree());


                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 315:20: ->
                    {
                        adaptor.addChild(root_0, new Constant(e2.tree));

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:316:4: NULL
                    {
                    NULL223=(Token)match(input,NULL,FOLLOW_NULL_in_constant3017);  
                    stream_NULL.add(NULL223);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 316:9: ->
                    {
                        adaptor.addChild(root_0, new Constant(NULL223));

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 4 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:317:4: StringLiteral
                    {
                    StringLiteral224=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_constant3026);  
                    stream_StringLiteral.add(StringLiteral224);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 317:18: ->
                    {
                        adaptor.addChild(root_0, new Constant(StringLiteral224));

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "constant"

    public static class constant_real_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constant_real"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:1: constant_real : ( MINUS )? Real -> ^( TextNode ( MINUS )? Real ) ;
    public final HbaseSQLParser.constant_real_return constant_real() throws RecognitionException {
        HbaseSQLParser.constant_real_return retval = new HbaseSQLParser.constant_real_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token MINUS225=null;
        Token Real226=null;

        CommonTree MINUS225_tree=null;
        CommonTree Real226_tree=null;
        RewriteRuleTokenStream stream_Real=new RewriteRuleTokenStream(adaptor,"token Real");
        RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:14: ( ( MINUS )? Real -> ^( TextNode ( MINUS )? Real ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:16: ( MINUS )? Real
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:16: ( MINUS )?
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==MINUS) ) {
                alt70=1;
            }
            switch (alt70) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:16: MINUS
                    {
                    MINUS225=(Token)match(input,MINUS,FOLLOW_MINUS_in_constant_real3036);  
                    stream_MINUS.add(MINUS225);


                    }
                    break;

            }

            Real226=(Token)match(input,Real,FOLLOW_Real_in_constant_real3039);  
            stream_Real.add(Real226);



            // AST REWRITE
            // elements: Real, MINUS
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 318:28: -> ^( TextNode ( MINUS )? Real )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:31: ^( TextNode ( MINUS )? Real )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:318:42: ( MINUS )?
                if ( stream_MINUS.hasNext() ) {
                    adaptor.addChild(root_1, stream_MINUS.nextNode());

                }
                stream_MINUS.reset();
                adaptor.addChild(root_1, stream_Real.nextNode());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "constant_real"

    public static class constant_int_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constant_int"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:1: constant_int : ( MINUS )? Integer -> ^( TextNode ( MINUS )? Integer ) ;
    public final HbaseSQLParser.constant_int_return constant_int() throws RecognitionException {
        HbaseSQLParser.constant_int_return retval = new HbaseSQLParser.constant_int_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token MINUS227=null;
        Token Integer228=null;

        CommonTree MINUS227_tree=null;
        CommonTree Integer228_tree=null;
        RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
        RewriteRuleTokenStream stream_Integer=new RewriteRuleTokenStream(adaptor,"token Integer");

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:13: ( ( MINUS )? Integer -> ^( TextNode ( MINUS )? Integer ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:15: ( MINUS )? Integer
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:15: ( MINUS )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( (LA71_0==MINUS) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:15: MINUS
                    {
                    MINUS227=(Token)match(input,MINUS,FOLLOW_MINUS_in_constant_int3056);  
                    stream_MINUS.add(MINUS227);


                    }
                    break;

            }

            Integer228=(Token)match(input,Integer,FOLLOW_Integer_in_constant_int3059);  
            stream_Integer.add(Integer228);



            // AST REWRITE
            // elements: Integer, MINUS
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 319:30: -> ^( TextNode ( MINUS )? Integer )
            {
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:33: ^( TextNode ( MINUS )? Integer )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TextNode, "TextNode"), root_1);

                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:319:44: ( MINUS )?
                if ( stream_MINUS.hasNext() ) {
                    adaptor.addChild(root_1, stream_MINUS.nextNode());

                }
                stream_MINUS.reset();
                adaptor.addChild(root_1, stream_Integer.nextNode());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "constant_int"

    public static class userVariable_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "userVariable"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:320:1: userVariable : UserVariable ->;
    public final HbaseSQLParser.userVariable_return userVariable() throws RecognitionException {
        HbaseSQLParser.userVariable_return retval = new HbaseSQLParser.userVariable_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token UserVariable229=null;

        CommonTree UserVariable229_tree=null;
        RewriteRuleTokenStream stream_UserVariable=new RewriteRuleTokenStream(adaptor,"token UserVariable");

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:320:13: ( UserVariable ->)
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:320:15: UserVariable
            {
            UserVariable229=(Token)match(input,UserVariable,FOLLOW_UserVariable_in_userVariable3076);  
            stream_UserVariable.add(UserVariable229);



            // AST REWRITE
            // elements: 
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 320:28: ->
            {
                adaptor.addChild(root_0, new UserVariable(UserVariable229));

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "userVariable"

    public static class createClause_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "createClause"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:383:1: createClause : ;
    public final HbaseSQLParser.createClause_return createClause() throws RecognitionException {
        HbaseSQLParser.createClause_return retval = new HbaseSQLParser.createClause_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:383:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:383:14: 
            {
            root_0 = (CommonTree)adaptor.nil();

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "createClause"

    public static class dropClause_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "dropClause"
    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:384:1: dropClause : ;
    public final HbaseSQLParser.dropClause_return dropClause() throws RecognitionException {
        HbaseSQLParser.dropClause_return retval = new HbaseSQLParser.dropClause_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        try {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:384:11: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:384:12: 
            {
            root_0 = (CommonTree)adaptor.nil();

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "dropClause"

    // Delegated rules


 

    public static final BitSet FOLLOW_statements_in_start953 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statements962 = new BitSet(new long[]{0x2001001004000000L,0x0000000001400022L});
    public static final BitSet FOLLOW_SEMI_in_statements965 = new BitSet(new long[]{0x2001001004000000L,0x0000000001400022L});
    public static final BitSet FOLLOW_EOF_in_statements972 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_selectStatement_in_statement986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_updateStatement_in_statement991 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_deleteStatement_in_statement996 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_insertStatement_in_statement1001 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_createTableStatement_in_statement1006 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_dropTableStatement_in_statement1011 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CREATE_in_createTableStatement1022 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_TABLE_in_createTableStatement1024 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_createTableStatement1026 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_columns_in_createTableStatement1028 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DROP_in_dropTableStatement1039 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_TABLE_in_dropTableStatement1041 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_dropTableStatement1043 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_select_1_in_selectStatement1057 = new BitSet(new long[]{0x0400000000000002L,0x0000000000000001L});
    public static final BitSet FOLLOW_UNION_in_selectStatement1060 = new BitSet(new long[]{0x2000000010000000L});
    public static final BitSet FOLLOW_ALL_in_selectStatement1062 = new BitSet(new long[]{0x2000000010000000L});
    public static final BitSet FOLLOW_select_2_in_selectStatement1065 = new BitSet(new long[]{0x0400000000000002L,0x0000000000000001L});
    public static final BitSet FOLLOW_orderBy_in_selectStatement1071 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_select_in_select_11138 = new BitSet(new long[]{0x0000180000000002L,0x0000000000000010L});
    public static final BitSet FOLLOW_from_in_select_11140 = new BitSet(new long[]{0x0000100000000002L,0x0000000000000010L});
    public static final BitSet FOLLOW_where_in_select_11143 = new BitSet(new long[]{0x0000100000000002L});
    public static final BitSet FOLLOW_groupBy_in_select_11146 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_select_1_in_select_21153 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_subQuery1160 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_selectStatement_in_subQuery1162 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_subQuery1164 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_update_in_updateStatement1175 = new BitSet(new long[]{0x0000080000000002L,0x0000000000000010L});
    public static final BitSet FOLLOW_from_in_updateStatement1177 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L});
    public static final BitSet FOLLOW_where_in_updateStatement1180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_delete_in_deleteStatement1187 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L});
    public static final BitSet FOLLOW_where_in_deleteStatement1189 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_truncate_in_deleteStatement1194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_insert_in_insertStatement1200 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_values_in_insertStatement1203 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_selectStatement_in_insertStatement1207 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SELECT_in_select1220 = new BitSet(new long[]{0x0080004400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_DISTINCT_in_select1222 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_columns_in_select1225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FROM_in_from1247 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_tables_in_from1250 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHERE_in_where1257 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_condition_in_where1259 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ORDER_in_orderBy1279 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_BY_in_orderBy1281 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_orderBy_1_in_orderBy1283 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_COMMA_in_orderBy1286 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_orderBy_1_in_orderBy1288 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_expressions_in_orderBy_11317 = new BitSet(new long[]{0x0000002080000002L});
    public static final BitSet FOLLOW_ASC_in_orderBy_11325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DESC_in_orderBy_11334 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GROUP_in_groupBy1395 = new BitSet(new long[]{0x0000000200000000L});
    public static final BitSet FOLLOW_BY_in_groupBy1397 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_groupBy1399 = new BitSet(new long[]{0x0000200002000002L});
    public static final BitSet FOLLOW_COMMA_in_groupBy1402 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_groupBy1404 = new BitSet(new long[]{0x0000200002000002L});
    public static final BitSet FOLLOW_having_in_groupBy1408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_HAVING_in_having1434 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_condition_in_having1437 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_UPDATE_in_update1445 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_update1447 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_SET_in_update1449 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_update1451 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_Eq_in_update1453 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_update1455 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_update_1_in_update1457 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_COMMA_in_update_11496 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_update_11498 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_Eq_in_update_11500 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_update_11502 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DELETE_in_delete1525 = new BitSet(new long[]{0x0080080400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_FROM_in_delete1527 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_delete1530 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRUNCATE_in_truncate1553 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_truncate1555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INSERT_in_insert1575 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_INTO_in_insert1577 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_insert1579 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_LPAREN_in_insert1581 = new BitSet(new long[]{0x0000000000800000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_insert1584 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_COMMA_in_insert1587 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_insert1589 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_RPAREN_in_insert1595 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VALUES_in_values1601 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_LPAREN_in_values1603 = new BitSet(new long[]{0x0080000400C18000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_values1606 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_COMMA_in_values1609 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_values1611 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_RPAREN_in_values1617 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_column_in_columns1623 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_COMMA_in_columns1627 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_column_in_columns1629 = new BitSet(new long[]{0x0000000002000002L});
    public static final BitSet FOLLOW_MUL_in_column1646 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_column1662 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_DOT_in_column1664 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_MUL_in_column1666 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressions_in_column1689 = new BitSet(new long[]{0x0000000040000002L,0x0000000006000000L});
    public static final BitSet FOLLOW_columnAlias_in_column1691 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_table_in_tables1717 = new BitSet(new long[]{0x1010800802000002L});
    public static final BitSet FOLLOW_tables_0_in_tables1719 = new BitSet(new long[]{0x1010800802000002L});
    public static final BitSet FOLLOW_COMMA_in_tables_01727 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_tables_01729 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_join_in_tables_01737 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subQuery_in_table1754 = new BitSet(new long[]{0x0000000040000002L,0x0000000006000000L});
    public static final BitSet FOLLOW_tableAlias_in_table1756 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_table1777 = new BitSet(new long[]{0x0000000040000002L,0x0000000006000000L});
    public static final BitSet FOLLOW_tableAlias_in_table1779 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CROSS_in_join1823 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_JOIN_in_join1825 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_join1827 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INNER_in_join1837 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_LEFT_in_join1846 = new BitSet(new long[]{0x0808000000000000L});
    public static final BitSet FOLLOW_RIGHT_in_join1854 = new BitSet(new long[]{0x0808000000000000L});
    public static final BitSet FOLLOW_OUTER_in_join1860 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_JOIN_in_join1864 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_table_in_join1866 = new BitSet(new long[]{0x0100000000000002L});
    public static final BitSet FOLLOW_ON_in_join1869 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_condition_in_join1871 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AS_in_columnAlias2004 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_columnAlias2007 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AS_in_tableAlias2025 = new BitSet(new long[]{0x0000000000000000L,0x0000000006000000L});
    public static final BitSet FOLLOW_identifier_in_tableAlias2028 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subCondition_in_condition2042 = new BitSet(new long[]{0x0200000020000002L});
    public static final BitSet FOLLOW_AND_in_condition2046 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_OR_in_condition2052 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_subCondition_in_condition2057 = new BitSet(new long[]{0x0200000020000002L});
    public static final BitSet FOLLOW_NOT_in_subCondition2069 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_LPAREN_in_subCondition2080 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_condition_in_subCondition2082 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_subCondition2084 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_predicate_in_subCondition2095 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressions_in_predicate2157 = new BitSet(new long[]{0x0064400100001FF0L});
    public static final BitSet FOLLOW_comparisonOperator_in_predicate2160 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_predicate2163 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IS_in_predicate2185 = new BitSet(new long[]{0x00C0000000000000L});
    public static final BitSet FOLLOW_NOT_in_predicate2188 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_NULL_in_predicate2192 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_predicate2222 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_IN_in_predicate2225 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_LPAREN_in_predicate2227 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_0_in_predicate2229 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_COMMA_in_predicate2232 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_1_in_predicate2234 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_RPAREN_in_predicate2238 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_predicate2268 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_IN_in_predicate2271 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_subQuery_in_predicate2273 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_predicate2300 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_BETWEEN_in_predicate2303 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_predicate2305 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_AND_in_predicate2307 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_predicate2309 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EXISTS_in_predicate2347 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_subQuery_in_predicate2349 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressions2366 = new BitSet(new long[]{0x000000000003E002L});
    public static final BitSet FOLLOW_mathOperator_in_expressions2369 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expression_in_expressions2371 = new BitSet(new long[]{0x000000000003E002L});
    public static final BitSet FOLLOW_expressions_in_expressions_02380 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressions_in_expressions_12386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_function_in_expression2403 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_in_expression2422 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_userVariable_in_expression2432 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_expression2441 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subQuery_in_expression2450 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_mathOperator0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_comparisonOperator0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_systemFunction_in_function2552 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_userFunction_in_function2556 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifier_in_userFunction2565 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_LPAREN_in_userFunction2567 = new BitSet(new long[]{0x0080000400C18000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_userFunction2570 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_COMMA_in_userFunction2573 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_0_in_userFunction2575 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_RPAREN_in_userFunction2581 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fnCase_in_systemFunction2608 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unitarySysFun_in_systemFunction2612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fnLen_in_systemFunction2616 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CASE_in_fnCase2629 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC8L});
    public static final BitSet FOLLOW_expressions_in_fnCase2644 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_WHEN_in_fnCase2647 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_fnCase2649 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_THEN_in_fnCase2651 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_fnCase2653 = new BitSet(new long[]{0x0000018000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_WHEN_in_fnCase2668 = new BitSet(new long[]{0x00C0020400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_condition_in_fnCase2670 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_THEN_in_fnCase2672 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_fnCase2674 = new BitSet(new long[]{0x0000018000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_ELSE_in_fnCase2697 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_fnCase2699 = new BitSet(new long[]{0x0000010000000000L});
    public static final BitSet FOLLOW_END_in_fnCase2703 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEN_in_fnLen2716 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_LPAREN_in_fnLen2718 = new BitSet(new long[]{0x0080000400418000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_expressions_in_fnLen2720 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_fnLen2722 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUM_in_unitarySysFun2742 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_AVG_in_unitarySysFun2747 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_MAX_in_unitarySysFun2752 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_MIN_in_unitarySysFun2757 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_COUNT_in_unitarySysFun2762 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_unitarySysFun_0_in_unitarySysFun2766 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_unitarySysFun_02776 = new BitSet(new long[]{0x0080000400C18000L,0x000000007E000FC0L});
    public static final BitSet FOLLOW_MUL_in_unitarySysFun_02780 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_expressions_in_unitarySysFun_02788 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_unitarySysFun_02795 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QuotedIdentifier_in_identifier2836 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NonQuotedIdentifier_in_identifier2845 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_datatypeNParam_in_datatype2859 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_datatypeOneParam_in_datatype2872 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_datatypeNoParam_in_datatype2885 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_datatypeNoParam0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_datatypeOneParam2914 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_LPAREN_in_datatypeOneParam2946 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
    public static final BitSet FOLLOW_Integer_in_datatypeOneParam2948 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_datatypeOneParam2950 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DECIMAL_in_datatypeNParam2963 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_LPAREN_in_datatypeNParam2970 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
    public static final BitSet FOLLOW_Integer_in_datatypeNParam2972 = new BitSet(new long[]{0x0000000002800000L});
    public static final BitSet FOLLOW_COMMA_in_datatypeNParam2975 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
    public static final BitSet FOLLOW_Integer_in_datatypeNParam2977 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RPAREN_in_datatypeNParam2981 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_real_in_constant2997 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_int_in_constant3008 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NULL_in_constant3017 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_constant3026 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MINUS_in_constant_real3036 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_Real_in_constant_real3039 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MINUS_in_constant_int3056 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
    public static final BitSet FOLLOW_Integer_in_constant_int3059 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_UserVariable_in_userVariable3076 = new BitSet(new long[]{0x0000000000000002L});

}